//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS DatabaseMigrationService service.
///
/// Database Migration Service Database Migration Service (DMS) can migrate your data to and from the most widely used commercial and open-source databases such as Oracle, PostgreSQL, Microsoft SQL Server, Amazon Redshift, MariaDB, Amazon Aurora, MySQL, and SAP Adaptive Server Enterprise (ASE). The service supports homogeneous migrations such as Oracle to Oracle, as well as heterogeneous migrations between different database platforms, such as Oracle to MySQL or SQL Server to PostgreSQL. For more information about DMS, see What Is Database Migration Service? in the Database Migration Service User Guide.
public struct DatabaseMigrationService: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the DatabaseMigrationService client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "AmazonDMSv20160101",
            serviceName: "DatabaseMigrationService",
            serviceIdentifier: "dms",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2016-01-01",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: DatabaseMigrationServiceErrorType.self,
            xmlNamespace: "http://dms.amazonaws.com/doc/2016-01-01/",
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.fips]: .init(endpoints: [
            "us-east-1": "dms-fips.us-east-1.amazonaws.com",
            "us-east-2": "dms-fips.us-east-2.amazonaws.com",
            "us-gov-east-1": "dms.us-gov-east-1.amazonaws.com",
            "us-gov-west-1": "dms.us-gov-west-1.amazonaws.com",
            "us-iso-east-1": "dms.us-iso-east-1.c2s.ic.gov",
            "us-iso-west-1": "dms.us-iso-west-1.c2s.ic.gov",
            "us-isob-east-1": "dms.us-isob-east-1.sc2s.sgov.gov",
            "us-isof-east-1": "dms.us-isof-east-1.csp.hci.ic.gov",
            "us-isof-south-1": "dms.us-isof-south-1.csp.hci.ic.gov",
            "us-west-1": "dms-fips.us-west-1.amazonaws.com",
            "us-west-2": "dms-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Adds metadata tags to an DMS resource, including replication instance, endpoint, subnet group, and migration task. These tags can also be used with cost allocation reporting to track cost associated with DMS resources, or used in a Condition statement in an IAM policy for DMS. For more information, see  Tag data type description.
    @Sendable
    @inlinable
    public func addTagsToResource(_ input: AddTagsToResourceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> AddTagsToResourceResponse {
        try await self.client.execute(
            operation: "AddTagsToResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds metadata tags to an DMS resource, including replication instance, endpoint, subnet group, and migration task. These tags can also be used with cost allocation reporting to track cost associated with DMS resources, or used in a Condition statement in an IAM policy for DMS. For more information, see  Tag data type description.
    ///
    /// Parameters:
    ///   - resourceArn: Identifies the DMS resource to which tags should be added. The value for this parameter is an Amazon Resource Name (ARN). For DMS, you can tag a replication instance, an endpoint, or a replication task.
    ///   - tags: One or more tags to be assigned to the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func addTagsToResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AddTagsToResourceResponse {
        let input = AddTagsToResourceMessage(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.addTagsToResource(input, logger: logger)
    }

    /// Applies a pending maintenance action to a resource (for example, to a replication instance).
    @Sendable
    @inlinable
    public func applyPendingMaintenanceAction(_ input: ApplyPendingMaintenanceActionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ApplyPendingMaintenanceActionResponse {
        try await self.client.execute(
            operation: "ApplyPendingMaintenanceAction", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies a pending maintenance action to a resource (for example, to a replication instance).
    ///
    /// Parameters:
    ///   - applyAction: The pending maintenance action to apply to this resource. Valid values: os-upgrade, system-update, db-upgrade, os-patch
    ///   - optInType: A value that specifies the type of opt-in request, or undoes an opt-in request. You can't undo an opt-in request of type immediate. Valid values:    immediate - Apply the maintenance action immediately.    next-maintenance - Apply the maintenance action during the next maintenance window for the resource.    undo-opt-in - Cancel any existing next-maintenance opt-in requests.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the DMS resource that the pending maintenance action applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func applyPendingMaintenanceAction(
        applyAction: String,
        optInType: String,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ApplyPendingMaintenanceActionResponse {
        let input = ApplyPendingMaintenanceActionMessage(
            applyAction: applyAction, 
            optInType: optInType, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.applyPendingMaintenanceAction(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Starts the analysis of up to 20 source databases to recommend target engines for each source database. This is a batch version of StartRecommendations. The result of analysis of each source database is reported individually in the response. Because the batch request can result in a combination of successful and unsuccessful actions, you should check for batch errors even when the call returns an HTTP status code of 200.
    @Sendable
    @inlinable
    public func batchStartRecommendations(_ input: BatchStartRecommendationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchStartRecommendationsResponse {
        try await self.client.execute(
            operation: "BatchStartRecommendations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Starts the analysis of up to 20 source databases to recommend target engines for each source database. This is a batch version of StartRecommendations. The result of analysis of each source database is reported individually in the response. Because the batch request can result in a combination of successful and unsuccessful actions, you should check for batch errors even when the call returns an HTTP status code of 200.
    ///
    /// Parameters:
    ///   - data: Provides information about source databases to analyze. After this analysis, Fleet Advisor recommends target engines for each source database.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchStartRecommendations(
        data: [StartRecommendationsRequestEntry]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchStartRecommendationsResponse {
        let input = BatchStartRecommendationsRequest(
            data: data
        )
        return try await self.batchStartRecommendations(input, logger: logger)
    }

    /// Cancels a single premigration assessment run. This operation prevents any individual assessments from running if they haven't started running. It also attempts to cancel any individual assessments that are currently running.
    @Sendable
    @inlinable
    public func cancelReplicationTaskAssessmentRun(_ input: CancelReplicationTaskAssessmentRunMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelReplicationTaskAssessmentRunResponse {
        try await self.client.execute(
            operation: "CancelReplicationTaskAssessmentRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels a single premigration assessment run. This operation prevents any individual assessments from running if they haven't started running. It also attempts to cancel any individual assessments that are currently running.
    ///
    /// Parameters:
    ///   - replicationTaskAssessmentRunArn: Amazon Resource Name (ARN) of the premigration assessment run to be canceled.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelReplicationTaskAssessmentRun(
        replicationTaskAssessmentRunArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelReplicationTaskAssessmentRunResponse {
        let input = CancelReplicationTaskAssessmentRunMessage(
            replicationTaskAssessmentRunArn: replicationTaskAssessmentRunArn
        )
        return try await self.cancelReplicationTaskAssessmentRun(input, logger: logger)
    }

    /// Creates a data migration using the provided settings.
    @Sendable
    @inlinable
    public func createDataMigration(_ input: CreateDataMigrationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataMigrationResponse {
        try await self.client.execute(
            operation: "CreateDataMigration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a data migration using the provided settings.
    ///
    /// Parameters:
    ///   - dataMigrationName: A user-friendly name for the data migration. Data migration names have the following constraints:   Must begin with a letter, and can only contain ASCII letters, digits, and hyphens.    Can't end with a hyphen or contain two consecutive hyphens.   Length must be from 1 to 255 characters.
    ///   - dataMigrationType: Specifies if the data migration is full-load only, change data capture (CDC) only, or full-load and CDC.
    ///   - enableCloudwatchLogs: Specifies whether to enable CloudWatch logs for the data migration.
    ///   - migrationProjectIdentifier: An identifier for the migration project.
    ///   - numberOfJobs: The number of parallel jobs that trigger parallel threads to unload the tables from the source, and then load them to the target.
    ///   - selectionRules: An optional JSON string specifying what tables, views, and schemas to include or exclude from the migration.
    ///   - serviceAccessRoleArn: The Amazon Resource Name (ARN) for the service access role that you want to use to create the data migration.
    ///   - sourceDataSettings: Specifies information about the source data provider.
    ///   - tags: One or more tags to be assigned to the data migration.
    ///   - targetDataSettings: Specifies information about the target data provider.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataMigration(
        dataMigrationName: String? = nil,
        dataMigrationType: MigrationTypeValue,
        enableCloudwatchLogs: Bool? = nil,
        migrationProjectIdentifier: String,
        numberOfJobs: Int? = nil,
        selectionRules: String? = nil,
        serviceAccessRoleArn: String,
        sourceDataSettings: [SourceDataSetting]? = nil,
        tags: [Tag]? = nil,
        targetDataSettings: [TargetDataSetting]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataMigrationResponse {
        let input = CreateDataMigrationMessage(
            dataMigrationName: dataMigrationName, 
            dataMigrationType: dataMigrationType, 
            enableCloudwatchLogs: enableCloudwatchLogs, 
            migrationProjectIdentifier: migrationProjectIdentifier, 
            numberOfJobs: numberOfJobs, 
            selectionRules: selectionRules, 
            serviceAccessRoleArn: serviceAccessRoleArn, 
            sourceDataSettings: sourceDataSettings, 
            tags: tags, 
            targetDataSettings: targetDataSettings
        )
        return try await self.createDataMigration(input, logger: logger)
    }

    /// Creates a data provider using the provided settings. A data provider stores a data store type and location information about your database.
    @Sendable
    @inlinable
    public func createDataProvider(_ input: CreateDataProviderMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateDataProviderResponse {
        try await self.client.execute(
            operation: "CreateDataProvider", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a data provider using the provided settings. A data provider stores a data store type and location information about your database.
    ///
    /// Parameters:
    ///   - dataProviderName: A user-friendly name for the data provider.
    ///   - description: A user-friendly description of the data provider.
    ///   - engine: The type of database engine for the data provider. Valid values include "aurora",  "aurora-postgresql", "mysql", "oracle", "postgres",  "sqlserver", redshift, mariadb, mongodb, db2, db2-zos and docdb. A value of "aurora" represents Amazon Aurora MySQL-Compatible Edition.
    ///   - settings: The settings in JSON format for a data provider.
    ///   - tags: One or more tags to be assigned to the data provider.
    ///   - virtual: Indicates whether the data provider is virtual.
    ///   - logger: Logger use during operation
    @inlinable
    public func createDataProvider(
        dataProviderName: String? = nil,
        description: String? = nil,
        engine: String,
        settings: DataProviderSettings,
        tags: [Tag]? = nil,
        virtual: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateDataProviderResponse {
        let input = CreateDataProviderMessage(
            dataProviderName: dataProviderName, 
            description: description, 
            engine: engine, 
            settings: settings, 
            tags: tags, 
            virtual: virtual
        )
        return try await self.createDataProvider(input, logger: logger)
    }

    /// Creates an endpoint using the provided settings.  For a MySQL source or target endpoint, don't explicitly specify the database using the DatabaseName request parameter on the CreateEndpoint API call. Specifying DatabaseName when you create a MySQL endpoint replicates all the task tables to this single database. For MySQL endpoints, you specify the database only when you specify the schema in the table-mapping rules of the DMS task.
    @Sendable
    @inlinable
    public func createEndpoint(_ input: CreateEndpointMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEndpointResponse {
        try await self.client.execute(
            operation: "CreateEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an endpoint using the provided settings.  For a MySQL source or target endpoint, don't explicitly specify the database using the DatabaseName request parameter on the CreateEndpoint API call. Specifying DatabaseName when you create a MySQL endpoint replicates all the task tables to this single database. For MySQL endpoints, you specify the database only when you specify the schema in the table-mapping rules of the DMS task.
    ///
    /// Parameters:
    ///   - certificateArn: The Amazon Resource Name (ARN) for the certificate.
    ///   - databaseName: The name of the endpoint database. For a MySQL source or target endpoint, do not specify DatabaseName. To migrate to a specific database, use this setting and targetDbType.
    ///   - dmsTransferSettings: The settings in JSON format for the DMS transfer type of source endpoint.  Possible settings include the following:    ServiceAccessRoleArn - The Amazon Resource Name (ARN) used by the service access IAM role. The role must allow the iam:PassRole action.    BucketName - The name of the S3 bucket to use.   Shorthand syntax for these settings is as follows: ServiceAccessRoleArn=string,BucketName=string  JSON syntax for these settings is as follows: { "ServiceAccessRoleArn": "string", "BucketName": "string", }
    ///   - docDbSettings: 
    ///   - dynamoDbSettings: Settings in JSON format for the target Amazon DynamoDB endpoint. For information about other available settings, see Using Object Mapping to Migrate Data to DynamoDB in the Database Migration Service User Guide.
    ///   - elasticsearchSettings: Settings in JSON format for the target OpenSearch endpoint. For more information about the available settings, see Extra Connection Attributes When Using OpenSearch as a Target for DMS in the Database Migration Service User Guide.
    ///   - endpointIdentifier: The database endpoint identifier. Identifiers must begin with a letter and must contain only ASCII letters, digits, and hyphens. They can't end with a hyphen, or contain two consecutive hyphens.
    ///   - endpointType: The type of endpoint. Valid values are source and target.
    ///   - engineName: The type of engine for the endpoint. Valid values, depending on the EndpointType value, include "mysql", "oracle", "postgres", "mariadb", "aurora", "aurora-postgresql", "opensearch", "redshift", "s3", "db2", "db2-zos", "azuredb", "sybase", "dynamodb", "mongodb", "kinesis", "kafka", "elasticsearch", "docdb", "sqlserver", "neptune", "babelfish", redshift-serverless, aurora-serverless, aurora-postgresql-serverless, gcp-mysql, azure-sql-managed-instance, redis, dms-transfer.
    ///   - externalTableDefinition: The external table definition.
    ///   - extraConnectionAttributes: Additional attributes associated with the connection. Each attribute is specified as a name-value pair associated by an equal sign (=). Multiple attributes are separated by a semicolon (;) with no additional white space. For information on the attributes available for connecting your source or target endpoint, see Working with DMS Endpoints in the Database Migration Service User Guide.
    ///   - gcpMySQLSettings: Settings in JSON format for the source GCP MySQL endpoint.
    ///   - ibmDb2Settings: Settings in JSON format for the source IBM Db2 LUW endpoint. For information about other available settings, see Extra connection attributes when using Db2 LUW as a source for DMS in the Database Migration Service User Guide.
    ///   - kafkaSettings: Settings in JSON format for the target Apache Kafka endpoint. For more information about the available settings, see Using object mapping to migrate data to a Kafka topic in the Database Migration Service User Guide.
    ///   - kinesisSettings: Settings in JSON format for the target endpoint for Amazon Kinesis Data Streams. For more information about the available settings, see Using object mapping to migrate data to a Kinesis data stream in the Database Migration Service User Guide.
    ///   - kmsKeyId: An KMS key identifier that is used to encrypt the connection parameters for the endpoint. If you don't specify a value for the KmsKeyId parameter, then DMS uses your default encryption key. KMS creates the default encryption key for your Amazon Web Services account. Your Amazon Web Services account has a different default encryption key for each Amazon Web Services Region.
    ///   - microsoftSQLServerSettings: Settings in JSON format for the source and target Microsoft SQL Server endpoint. For information about other available settings, see Extra connection attributes when using SQL Server as a source for DMS and Extra connection attributes when using SQL Server as a target for DMS in the Database Migration Service User Guide.
    ///   - mongoDbSettings: Settings in JSON format for the source MongoDB endpoint. For more information about the available settings, see Endpoint configuration settings when using MongoDB as a source for Database Migration Service in the Database Migration Service User Guide.
    ///   - mySQLSettings: Settings in JSON format for the source and target MySQL endpoint. For information about other available settings, see Extra connection attributes when using MySQL as a source for DMS and Extra connection attributes when using a MySQL-compatible database as a target for DMS in the Database Migration Service User Guide.
    ///   - neptuneSettings: Settings in JSON format for the target Amazon Neptune endpoint. For more information about the available settings, see Specifying graph-mapping rules using Gremlin and R2RML for Amazon Neptune as a target in the Database Migration Service User Guide.
    ///   - oracleSettings: Settings in JSON format for the source and target Oracle endpoint. For information about other available settings, see Extra connection attributes when using Oracle as a source for DMS and  Extra connection attributes when using Oracle as a target for DMS in the Database Migration Service User Guide.
    ///   - password: The password to be used to log in to the endpoint database.
    ///   - port: The port used by the endpoint database.
    ///   - postgreSQLSettings: Settings in JSON format for the source and target PostgreSQL endpoint. For information about other available settings, see Extra connection attributes when using PostgreSQL as a source for DMS and Extra connection attributes when using PostgreSQL as a target for DMS in the Database Migration Service User Guide.
    ///   - redisSettings: Settings in JSON format for the target Redis endpoint.
    ///   - redshiftSettings: 
    ///   - resourceIdentifier: A friendly name for the resource identifier at the end of the EndpointArn response parameter that is returned in the created Endpoint object. The value for this parameter can have up to 31 characters. It can contain only ASCII letters, digits, and hyphen ('-'). Also, it can't end with a hyphen or contain two consecutive hyphens, and can only begin with a letter, such as Example-App-ARN1. For example, this value might result in the EndpointArn value arn:aws:dms:eu-west-1:012345678901:rep:Example-App-ARN1. If you don't specify a ResourceIdentifier value, DMS generates a default identifier value for the end of EndpointArn.
    ///   - s3Settings: Settings in JSON format for the target Amazon S3 endpoint. For more information about the available settings, see Extra Connection Attributes When Using Amazon S3 as a Target for DMS in the Database Migration Service User Guide.
    ///   - serverName: The name of the server where the endpoint database resides.
    ///   - serviceAccessRoleArn:  The Amazon Resource Name (ARN) for the service access role that you want to use to create the endpoint. The role must allow the iam:PassRole action.
    ///   - sslMode: The Secure Sockets Layer (SSL) mode to use for the SSL connection. The default is none
    ///   - sybaseSettings: Settings in JSON format for the source and target SAP ASE endpoint. For information about other available settings, see Extra connection attributes when using SAP ASE as a source for DMS and Extra connection attributes when using SAP ASE as a target for DMS in the Database Migration Service User Guide.
    ///   - tags: One or more tags to be assigned to the endpoint.
    ///   - timestreamSettings: Settings in JSON format for the target Amazon Timestream endpoint.
    ///   - username: The user name to be used to log in to the endpoint database.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEndpoint(
        certificateArn: String? = nil,
        databaseName: String? = nil,
        dmsTransferSettings: DmsTransferSettings? = nil,
        docDbSettings: DocDbSettings? = nil,
        dynamoDbSettings: DynamoDbSettings? = nil,
        elasticsearchSettings: ElasticsearchSettings? = nil,
        endpointIdentifier: String,
        endpointType: ReplicationEndpointTypeValue,
        engineName: String,
        externalTableDefinition: String? = nil,
        extraConnectionAttributes: String? = nil,
        gcpMySQLSettings: GcpMySQLSettings? = nil,
        ibmDb2Settings: IBMDb2Settings? = nil,
        kafkaSettings: KafkaSettings? = nil,
        kinesisSettings: KinesisSettings? = nil,
        kmsKeyId: String? = nil,
        microsoftSQLServerSettings: MicrosoftSQLServerSettings? = nil,
        mongoDbSettings: MongoDbSettings? = nil,
        mySQLSettings: MySQLSettings? = nil,
        neptuneSettings: NeptuneSettings? = nil,
        oracleSettings: OracleSettings? = nil,
        password: String? = nil,
        port: Int? = nil,
        postgreSQLSettings: PostgreSQLSettings? = nil,
        redisSettings: RedisSettings? = nil,
        redshiftSettings: RedshiftSettings? = nil,
        resourceIdentifier: String? = nil,
        s3Settings: S3Settings? = nil,
        serverName: String? = nil,
        serviceAccessRoleArn: String? = nil,
        sslMode: DmsSslModeValue? = nil,
        sybaseSettings: SybaseSettings? = nil,
        tags: [Tag]? = nil,
        timestreamSettings: TimestreamSettings? = nil,
        username: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEndpointResponse {
        let input = CreateEndpointMessage(
            certificateArn: certificateArn, 
            databaseName: databaseName, 
            dmsTransferSettings: dmsTransferSettings, 
            docDbSettings: docDbSettings, 
            dynamoDbSettings: dynamoDbSettings, 
            elasticsearchSettings: elasticsearchSettings, 
            endpointIdentifier: endpointIdentifier, 
            endpointType: endpointType, 
            engineName: engineName, 
            externalTableDefinition: externalTableDefinition, 
            extraConnectionAttributes: extraConnectionAttributes, 
            gcpMySQLSettings: gcpMySQLSettings, 
            ibmDb2Settings: ibmDb2Settings, 
            kafkaSettings: kafkaSettings, 
            kinesisSettings: kinesisSettings, 
            kmsKeyId: kmsKeyId, 
            microsoftSQLServerSettings: microsoftSQLServerSettings, 
            mongoDbSettings: mongoDbSettings, 
            mySQLSettings: mySQLSettings, 
            neptuneSettings: neptuneSettings, 
            oracleSettings: oracleSettings, 
            password: password, 
            port: port, 
            postgreSQLSettings: postgreSQLSettings, 
            redisSettings: redisSettings, 
            redshiftSettings: redshiftSettings, 
            resourceIdentifier: resourceIdentifier, 
            s3Settings: s3Settings, 
            serverName: serverName, 
            serviceAccessRoleArn: serviceAccessRoleArn, 
            sslMode: sslMode, 
            sybaseSettings: sybaseSettings, 
            tags: tags, 
            timestreamSettings: timestreamSettings, 
            username: username
        )
        return try await self.createEndpoint(input, logger: logger)
    }

    ///  Creates an DMS event notification subscription.  You can specify the type of source (SourceType) you want to be notified of, provide a list of DMS source IDs (SourceIds) that triggers the events, and provide a list of event categories (EventCategories) for events you want to be notified of. If you specify both the SourceType and SourceIds, such as SourceType = replication-instance and SourceIdentifier = my-replinstance, you will be notified of all the replication instance events for the specified source. If you specify a SourceType but don't specify a SourceIdentifier, you receive notice of the events for that source type for all your DMS sources. If you don't specify either SourceType nor SourceIdentifier, you will be notified of events generated from all DMS sources belonging to your customer account. For more information about DMS events, see Working with Events and Notifications in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func createEventSubscription(_ input: CreateEventSubscriptionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateEventSubscriptionResponse {
        try await self.client.execute(
            operation: "CreateEventSubscription", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Creates an DMS event notification subscription.  You can specify the type of source (SourceType) you want to be notified of, provide a list of DMS source IDs (SourceIds) that triggers the events, and provide a list of event categories (EventCategories) for events you want to be notified of. If you specify both the SourceType and SourceIds, such as SourceType = replication-instance and SourceIdentifier = my-replinstance, you will be notified of all the replication instance events for the specified source. If you specify a SourceType but don't specify a SourceIdentifier, you receive notice of the events for that source type for all your DMS sources. If you don't specify either SourceType nor SourceIdentifier, you will be notified of events generated from all DMS sources belonging to your customer account. For more information about DMS events, see Working with Events and Notifications in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - enabled:  A Boolean value; set to true to activate the subscription, or set to false to create the subscription but not activate it.
    ///   - eventCategories: A list of event categories for a source type that you want to subscribe to. For more information, see Working with Events and Notifications in the Database Migration Service User Guide.
    ///   - snsTopicArn:  The Amazon Resource Name (ARN) of the Amazon SNS topic created for event notification. The ARN is created by Amazon SNS when you create a topic and subscribe to it.
    ///   - sourceIds: A list of identifiers for which DMS provides notification events. If you don't specify a value, notifications are provided for all sources. If you specify multiple values, they must be of the same type. For example, if you specify a database instance ID, then all of the other values must be database instance IDs.
    ///   - sourceType:  The type of DMS resource that generates the events. For example, if you want to be notified of events generated by a replication instance, you set this parameter to replication-instance. If this value isn't specified, all events are returned.  Valid values: replication-instance | replication-task
    ///   - subscriptionName: The name of the DMS event notification subscription. This name must be less than 255 characters.
    ///   - tags: One or more tags to be assigned to the event subscription.
    ///   - logger: Logger use during operation
    @inlinable
    public func createEventSubscription(
        enabled: Bool? = nil,
        eventCategories: [String]? = nil,
        snsTopicArn: String,
        sourceIds: [String]? = nil,
        sourceType: String? = nil,
        subscriptionName: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateEventSubscriptionResponse {
        let input = CreateEventSubscriptionMessage(
            enabled: enabled, 
            eventCategories: eventCategories, 
            snsTopicArn: snsTopicArn, 
            sourceIds: sourceIds, 
            sourceType: sourceType, 
            subscriptionName: subscriptionName, 
            tags: tags
        )
        return try await self.createEventSubscription(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Creates a Fleet Advisor collector using the specified parameters.
    @Sendable
    @inlinable
    public func createFleetAdvisorCollector(_ input: CreateFleetAdvisorCollectorRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFleetAdvisorCollectorResponse {
        try await self.client.execute(
            operation: "CreateFleetAdvisorCollector", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Creates a Fleet Advisor collector using the specified parameters.
    ///
    /// Parameters:
    ///   - collectorName: The name of your Fleet Advisor collector (for example, sample-collector).
    ///   - description: A summary description of your Fleet Advisor collector.
    ///   - s3BucketName: The Amazon S3 bucket that the Fleet Advisor collector uses to store inventory metadata.
    ///   - serviceAccessRoleArn: The IAM role that grants permissions to access the specified Amazon S3 bucket.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFleetAdvisorCollector(
        collectorName: String,
        description: String? = nil,
        s3BucketName: String,
        serviceAccessRoleArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFleetAdvisorCollectorResponse {
        let input = CreateFleetAdvisorCollectorRequest(
            collectorName: collectorName, 
            description: description, 
            s3BucketName: s3BucketName, 
            serviceAccessRoleArn: serviceAccessRoleArn
        )
        return try await self.createFleetAdvisorCollector(input, logger: logger)
    }

    /// Creates the instance profile using the specified parameters.
    @Sendable
    @inlinable
    public func createInstanceProfile(_ input: CreateInstanceProfileMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateInstanceProfileResponse {
        try await self.client.execute(
            operation: "CreateInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates the instance profile using the specified parameters.
    ///
    /// Parameters:
    ///   - availabilityZone: The Availability Zone where the instance profile will be created. The default value is a random, system-chosen Availability Zone in the Amazon Web Services Region where your  data provider is created, for examplem us-east-1d.
    ///   - description: A user-friendly description of the instance profile.
    ///   - instanceProfileName: A user-friendly name for the instance profile.
    ///   - kmsKeyArn: The Amazon Resource Name (ARN) of the KMS key that is used to encrypt  the connection parameters for the instance profile. If you don't specify a value for the KmsKeyArn parameter, then DMS uses an Amazon Web Services owned encryption key to encrypt your resources.
    ///   - networkType: Specifies the network type for the instance profile. A value of IPV4  represents an instance profile with IPv4 network type and only supports IPv4 addressing.  A value of IPV6 represents an instance profile with IPv6 network type  and only supports IPv6 addressing. A value of DUAL represents an instance  profile with dual network type that supports IPv4 and IPv6 addressing.
    ///   - publiclyAccessible: Specifies the accessibility options for the instance profile. A value of true represents an instance profile with a public IP address. A value of false represents an instance profile with a private IP address. The default value is true.
    ///   - subnetGroupIdentifier: A subnet group to associate with the instance profile.
    ///   - tags: One or more tags to be assigned to the instance profile.
    ///   - vpcSecurityGroups: Specifies the VPC security group names to be used with the instance profile.  The VPC security group must work with the VPC containing the instance profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func createInstanceProfile(
        availabilityZone: String? = nil,
        description: String? = nil,
        instanceProfileName: String? = nil,
        kmsKeyArn: String? = nil,
        networkType: String? = nil,
        publiclyAccessible: Bool? = nil,
        subnetGroupIdentifier: String? = nil,
        tags: [Tag]? = nil,
        vpcSecurityGroups: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateInstanceProfileResponse {
        let input = CreateInstanceProfileMessage(
            availabilityZone: availabilityZone, 
            description: description, 
            instanceProfileName: instanceProfileName, 
            kmsKeyArn: kmsKeyArn, 
            networkType: networkType, 
            publiclyAccessible: publiclyAccessible, 
            subnetGroupIdentifier: subnetGroupIdentifier, 
            tags: tags, 
            vpcSecurityGroups: vpcSecurityGroups
        )
        return try await self.createInstanceProfile(input, logger: logger)
    }

    /// Creates the migration project using the specified parameters. You can run this action only after you create an instance profile and data providers using CreateInstanceProfile and CreateDataProvider.
    @Sendable
    @inlinable
    public func createMigrationProject(_ input: CreateMigrationProjectMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMigrationProjectResponse {
        try await self.client.execute(
            operation: "CreateMigrationProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates the migration project using the specified parameters. You can run this action only after you create an instance profile and data providers using CreateInstanceProfile and CreateDataProvider.
    ///
    /// Parameters:
    ///   - description: A user-friendly description of the migration project.
    ///   - instanceProfileIdentifier: The identifier of the associated instance profile. Identifiers must begin with a letter  and must contain only ASCII letters, digits, and hyphens. They can't end with  a hyphen, or contain two consecutive hyphens.
    ///   - migrationProjectName: A user-friendly name for the migration project.
    ///   - schemaConversionApplicationAttributes: The schema conversion application attributes, including the Amazon S3 bucket name and Amazon S3 role ARN.
    ///   - sourceDataProviderDescriptors: Information about the source data provider, including the name, ARN, and Secrets Manager parameters.
    ///   - tags: One or more tags to be assigned to the migration project.
    ///   - targetDataProviderDescriptors: Information about the target data provider, including the name, ARN, and Amazon Web Services Secrets Manager parameters.
    ///   - transformationRules: The settings in JSON format for migration rules. Migration rules make it possible for you to change  the object names according to the rules that you specify. For example, you can change an object name  to lowercase or uppercase, add or remove a prefix or suffix, or rename objects.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMigrationProject(
        description: String? = nil,
        instanceProfileIdentifier: String,
        migrationProjectName: String? = nil,
        schemaConversionApplicationAttributes: SCApplicationAttributes? = nil,
        sourceDataProviderDescriptors: [DataProviderDescriptorDefinition],
        tags: [Tag]? = nil,
        targetDataProviderDescriptors: [DataProviderDescriptorDefinition],
        transformationRules: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMigrationProjectResponse {
        let input = CreateMigrationProjectMessage(
            description: description, 
            instanceProfileIdentifier: instanceProfileIdentifier, 
            migrationProjectName: migrationProjectName, 
            schemaConversionApplicationAttributes: schemaConversionApplicationAttributes, 
            sourceDataProviderDescriptors: sourceDataProviderDescriptors, 
            tags: tags, 
            targetDataProviderDescriptors: targetDataProviderDescriptors, 
            transformationRules: transformationRules
        )
        return try await self.createMigrationProject(input, logger: logger)
    }

    /// Creates a configuration that you can later provide to configure and start an DMS Serverless replication. You can also provide options to validate the configuration inputs before you start the replication.
    @Sendable
    @inlinable
    public func createReplicationConfig(_ input: CreateReplicationConfigMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReplicationConfigResponse {
        try await self.client.execute(
            operation: "CreateReplicationConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a configuration that you can later provide to configure and start an DMS Serverless replication. You can also provide options to validate the configuration inputs before you start the replication.
    ///
    /// Parameters:
    ///   - computeConfig: Configuration parameters for provisioning an DMS Serverless replication.
    ///   - replicationConfigIdentifier: A unique identifier that you want to use to create a ReplicationConfigArn that is returned as part of the output from this action. You can then pass this output ReplicationConfigArn as the value of the ReplicationConfigArn option for other actions to identify both DMS Serverless replications and replication configurations that you want those actions to operate on. For some actions, you can also use either this unique identifier or a corresponding ARN in action filters to identify the specific replication and replication configuration to operate on.
    ///   - replicationSettings: Optional JSON settings for DMS Serverless replications that are provisioned using this replication configuration. For example, see  Change processing tuning settings.
    ///   - replicationType: The type of DMS Serverless replication to provision using this replication configuration. Possible values:    "full-load"     "cdc"     "full-load-and-cdc"
    ///   - resourceIdentifier: Optional unique value or name that you set for a given resource that can be used to construct an Amazon Resource Name (ARN) for that resource. For more information, see  Fine-grained access control using resource names and tags.
    ///   - sourceEndpointArn: The Amazon Resource Name (ARN) of the source endpoint for this DMS Serverless replication configuration.
    ///   - supplementalSettings: Optional JSON settings for specifying supplemental data. For more information, see  Specifying supplemental data for task settings.
    ///   - tableMappings: JSON table mappings for DMS Serverless replications that are provisioned using this replication configuration. For more information, see  Specifying table selection and transformations rules using JSON.
    ///   - tags: One or more optional tags associated with resources used by the DMS Serverless replication. For more information, see  Tagging resources in Database Migration Service.
    ///   - targetEndpointArn: The Amazon Resource Name (ARN) of the target endpoint for this DMS serverless replication configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createReplicationConfig(
        computeConfig: ComputeConfig,
        replicationConfigIdentifier: String,
        replicationSettings: String? = nil,
        replicationType: MigrationTypeValue,
        resourceIdentifier: String? = nil,
        sourceEndpointArn: String,
        supplementalSettings: String? = nil,
        tableMappings: String,
        tags: [Tag]? = nil,
        targetEndpointArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReplicationConfigResponse {
        let input = CreateReplicationConfigMessage(
            computeConfig: computeConfig, 
            replicationConfigIdentifier: replicationConfigIdentifier, 
            replicationSettings: replicationSettings, 
            replicationType: replicationType, 
            resourceIdentifier: resourceIdentifier, 
            sourceEndpointArn: sourceEndpointArn, 
            supplementalSettings: supplementalSettings, 
            tableMappings: tableMappings, 
            tags: tags, 
            targetEndpointArn: targetEndpointArn
        )
        return try await self.createReplicationConfig(input, logger: logger)
    }

    /// Creates the replication instance using the specified parameters. DMS requires that your account have certain roles with appropriate permissions before you can create a replication instance. For information on the required roles, see Creating the IAM Roles to Use With the CLI and DMS API. For information on the required permissions, see IAM Permissions Needed to Use DMS.  If you don't specify a version when creating a replication instance, DMS will create the instance using the default engine version. For information about the default engine version, see Release Notes.
    @Sendable
    @inlinable
    public func createReplicationInstance(_ input: CreateReplicationInstanceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReplicationInstanceResponse {
        try await self.client.execute(
            operation: "CreateReplicationInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates the replication instance using the specified parameters. DMS requires that your account have certain roles with appropriate permissions before you can create a replication instance. For information on the required roles, see Creating the IAM Roles to Use With the CLI and DMS API. For information on the required permissions, see IAM Permissions Needed to Use DMS.  If you don't specify a version when creating a replication instance, DMS will create the instance using the default engine version. For information about the default engine version, see Release Notes.
    ///
    /// Parameters:
    ///   - allocatedStorage: The amount of storage (in gigabytes) to be initially allocated for the replication instance.
    ///   - autoMinorVersionUpgrade: A value that indicates whether minor engine upgrades are applied automatically to the replication instance during the maintenance window. This parameter defaults to true. Default: true
    ///   - availabilityZone: The Availability Zone where the replication instance will be created. The default value is a random, system-chosen Availability Zone in the endpoint's Amazon Web Services Region, for example: us-east-1d.
    ///   - dnsNameServers: A list of custom DNS name servers supported for the replication instance to access your on-premise source or target database. This list overrides the default name servers supported by the replication instance. You can specify a comma-separated list of internet addresses for up to four on-premise DNS name servers. For example: "1.1.1.1,2.2.2.2,3.3.3.3,4.4.4.4"
    ///   - engineVersion: The engine version number of the replication instance. If an engine version number is not specified when a replication instance is created, the default is the latest engine version available.
    ///   - kerberosAuthenticationSettings: Specifies the settings required for kerberos authentication when creating the replication instance.
    ///   - kmsKeyId: An KMS key identifier that is used to encrypt the data on the replication instance. If you don't specify a value for the KmsKeyId parameter, then DMS uses your default encryption key. KMS creates the default encryption key for your Amazon Web Services account. Your Amazon Web Services account has a different default encryption key for each Amazon Web Services Region.
    ///   - multiAZ:  Specifies whether the replication instance is a Multi-AZ deployment. You can't set the AvailabilityZone parameter if the Multi-AZ parameter is set to true.
    ///   - networkType: The type of IP address protocol used by a replication instance, such as IPv4 only or Dual-stack that supports both IPv4 and IPv6 addressing. IPv6 only is not yet supported.
    ///   - preferredMaintenanceWindow: The weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC). Format: ddd:hh24:mi-ddd:hh24:mi  Default: A 30-minute window selected at random from an 8-hour block of time per Amazon Web Services Region, occurring on a random day of the week. Valid Days: Mon, Tue, Wed, Thu, Fri, Sat, Sun Constraints: Minimum 30-minute window.
    ///   - publiclyAccessible:  Specifies the accessibility options for the replication instance. A value of true represents an instance with a public IP address. A value of false represents an instance with a private IP address. The default value is true.
    ///   - replicationInstanceClass: The compute and memory capacity of the replication instance as defined for the specified replication instance class. For example to specify the instance class dms.c4.large, set this parameter to "dms.c4.large". For more information on the settings and capacities for the available replication instance classes, see  Choosing the right DMS replication instance; and, Selecting the best size for a replication instance.
    ///   - replicationInstanceIdentifier: The replication instance identifier. This parameter is stored as a lowercase string. Constraints:   Must contain 1-63 alphanumeric characters or hyphens.   First character must be a letter.   Can't end with a hyphen or contain two consecutive hyphens.   Example: myrepinstance
    ///   - replicationSubnetGroupIdentifier: A subnet group to associate with the replication instance.
    ///   - resourceIdentifier: A friendly name for the resource identifier at the end of the EndpointArn response parameter that is returned in the created Endpoint object. The value for this parameter can have up to 31 characters. It can contain only ASCII letters, digits, and hyphen ('-'). Also, it can't end with a hyphen or contain two consecutive hyphens, and can only begin with a letter, such as Example-App-ARN1. For example, this value might result in the EndpointArn value arn:aws:dms:eu-west-1:012345678901:rep:Example-App-ARN1. If you don't specify a ResourceIdentifier value, DMS generates a default identifier value for the end of EndpointArn.
    ///   - tags: One or more tags to be assigned to the replication instance.
    ///   - vpcSecurityGroupIds:  Specifies the VPC security group to be used with the replication instance. The VPC security group must work with the VPC containing the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func createReplicationInstance(
        allocatedStorage: Int? = nil,
        autoMinorVersionUpgrade: Bool? = nil,
        availabilityZone: String? = nil,
        dnsNameServers: String? = nil,
        engineVersion: String? = nil,
        kerberosAuthenticationSettings: KerberosAuthenticationSettings? = nil,
        kmsKeyId: String? = nil,
        multiAZ: Bool? = nil,
        networkType: String? = nil,
        preferredMaintenanceWindow: String? = nil,
        publiclyAccessible: Bool? = nil,
        replicationInstanceClass: String,
        replicationInstanceIdentifier: String,
        replicationSubnetGroupIdentifier: String? = nil,
        resourceIdentifier: String? = nil,
        tags: [Tag]? = nil,
        vpcSecurityGroupIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReplicationInstanceResponse {
        let input = CreateReplicationInstanceMessage(
            allocatedStorage: allocatedStorage, 
            autoMinorVersionUpgrade: autoMinorVersionUpgrade, 
            availabilityZone: availabilityZone, 
            dnsNameServers: dnsNameServers, 
            engineVersion: engineVersion, 
            kerberosAuthenticationSettings: kerberosAuthenticationSettings, 
            kmsKeyId: kmsKeyId, 
            multiAZ: multiAZ, 
            networkType: networkType, 
            preferredMaintenanceWindow: preferredMaintenanceWindow, 
            publiclyAccessible: publiclyAccessible, 
            replicationInstanceClass: replicationInstanceClass, 
            replicationInstanceIdentifier: replicationInstanceIdentifier, 
            replicationSubnetGroupIdentifier: replicationSubnetGroupIdentifier, 
            resourceIdentifier: resourceIdentifier, 
            tags: tags, 
            vpcSecurityGroupIds: vpcSecurityGroupIds
        )
        return try await self.createReplicationInstance(input, logger: logger)
    }

    /// Creates a replication subnet group given a list of the subnet IDs in a VPC. The VPC needs to have at least one subnet in at least two availability zones in the Amazon Web Services Region, otherwise the service will throw a ReplicationSubnetGroupDoesNotCoverEnoughAZs exception. If a replication subnet group exists in your Amazon Web Services account, the CreateReplicationSubnetGroup action returns the following error message: The Replication Subnet Group already exists. In this case, delete the existing replication subnet group. To do so, use the DeleteReplicationSubnetGroup action. Optionally, choose Subnet groups in the DMS console, then choose your subnet group. Next, choose Delete from Actions.
    @Sendable
    @inlinable
    public func createReplicationSubnetGroup(_ input: CreateReplicationSubnetGroupMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReplicationSubnetGroupResponse {
        try await self.client.execute(
            operation: "CreateReplicationSubnetGroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a replication subnet group given a list of the subnet IDs in a VPC. The VPC needs to have at least one subnet in at least two availability zones in the Amazon Web Services Region, otherwise the service will throw a ReplicationSubnetGroupDoesNotCoverEnoughAZs exception. If a replication subnet group exists in your Amazon Web Services account, the CreateReplicationSubnetGroup action returns the following error message: The Replication Subnet Group already exists. In this case, delete the existing replication subnet group. To do so, use the DeleteReplicationSubnetGroup action. Optionally, choose Subnet groups in the DMS console, then choose your subnet group. Next, choose Delete from Actions.
    ///
    /// Parameters:
    ///   - replicationSubnetGroupDescription: The description for the subnet group.  Constraints: This parameter Must not contain non-printable control characters.
    ///   - replicationSubnetGroupIdentifier: The name for the replication subnet group. This value is stored as a lowercase string. Constraints: Must contain no more than 255 alphanumeric characters, periods, underscores, or hyphens. Must not be "default". Example: mySubnetgroup
    ///   - subnetIds: Two or more subnet IDs to be assigned to the subnet group.
    ///   - tags: One or more tags to be assigned to the subnet group.
    ///   - logger: Logger use during operation
    @inlinable
    public func createReplicationSubnetGroup(
        replicationSubnetGroupDescription: String,
        replicationSubnetGroupIdentifier: String,
        subnetIds: [String],
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReplicationSubnetGroupResponse {
        let input = CreateReplicationSubnetGroupMessage(
            replicationSubnetGroupDescription: replicationSubnetGroupDescription, 
            replicationSubnetGroupIdentifier: replicationSubnetGroupIdentifier, 
            subnetIds: subnetIds, 
            tags: tags
        )
        return try await self.createReplicationSubnetGroup(input, logger: logger)
    }

    /// Creates a replication task using the specified parameters.
    @Sendable
    @inlinable
    public func createReplicationTask(_ input: CreateReplicationTaskMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateReplicationTaskResponse {
        try await self.client.execute(
            operation: "CreateReplicationTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a replication task using the specified parameters.
    ///
    /// Parameters:
    ///   - cdcStartPosition: Indicates when you want a change data capture (CDC) operation to start. Use either CdcStartPosition or CdcStartTime to specify when you want a CDC operation to start. Specifying both values results in an error. The value can be in date, checkpoint, or LSN/SCN format. Date Example: --cdc-start-position “2018-03-08T12:12:12” Checkpoint Example: --cdc-start-position "checkpoint:V1#27#mysql-bin-changelog.157832:1975:-1:2002:677883278264080:mysql-bin-changelog.157832:1876#0#0#*#0#93" LSN Example: --cdc-start-position “mysql-bin-changelog.000024:373”  When you use this task setting with a source PostgreSQL database, a logical replication slot should already be created and associated with the source endpoint. You can verify this by setting the slotName extra connection attribute to the name of this logical replication slot. For more information, see Extra Connection Attributes When Using PostgreSQL as a Source for DMS.
    ///   - cdcStartTime: Indicates the start time for a change data capture (CDC) operation. Use either CdcStartTime or CdcStartPosition to specify when you want a CDC operation to start. Specifying both values results in an error. Timestamp Example: --cdc-start-time “2018-03-08T12:12:12”
    ///   - cdcStopPosition: Indicates when you want a change data capture (CDC) operation to stop. The value can be either server time or commit time. Server time example: --cdc-stop-position “server_time:2018-02-09T12:12:12” Commit time example: --cdc-stop-position “commit_time:2018-02-09T12:12:12“
    ///   - migrationType: The migration type. Valid values: full-load | cdc | full-load-and-cdc
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of a replication instance.
    ///   - replicationTaskIdentifier: An identifier for the replication task. Constraints:   Must contain 1-255 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
    ///   - replicationTaskSettings: Overall settings for the task, in JSON format. For more information, see Specifying Task Settings for Database Migration Service Tasks in the Database Migration Service User Guide.
    ///   - resourceIdentifier: A friendly name for the resource identifier at the end of the EndpointArn response parameter that is returned in the created Endpoint object. The value for this parameter can have up to 31 characters. It can contain only ASCII letters, digits, and hyphen ('-'). Also, it can't end with a hyphen or contain two consecutive hyphens, and can only begin with a letter, such as Example-App-ARN1. For example, this value might result in the EndpointArn value arn:aws:dms:eu-west-1:012345678901:rep:Example-App-ARN1. If you don't specify a ResourceIdentifier value, DMS generates a default identifier value for the end of EndpointArn.
    ///   - sourceEndpointArn: An Amazon Resource Name (ARN) that uniquely identifies the source endpoint.
    ///   - tableMappings: The table mappings for the task, in JSON format. For more information, see Using Table Mapping to Specify Task Settings in the Database Migration Service User Guide.
    ///   - tags: One or more tags to be assigned to the replication task.
    ///   - targetEndpointArn: An Amazon Resource Name (ARN) that uniquely identifies the target endpoint.
    ///   - taskData: Supplemental information that the task requires to migrate the data for certain source and target endpoints. For more information, see Specifying Supplemental Data for Task Settings in the Database Migration Service User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func createReplicationTask(
        cdcStartPosition: String? = nil,
        cdcStartTime: Date? = nil,
        cdcStopPosition: String? = nil,
        migrationType: MigrationTypeValue,
        replicationInstanceArn: String,
        replicationTaskIdentifier: String,
        replicationTaskSettings: String? = nil,
        resourceIdentifier: String? = nil,
        sourceEndpointArn: String,
        tableMappings: String,
        tags: [Tag]? = nil,
        targetEndpointArn: String,
        taskData: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateReplicationTaskResponse {
        let input = CreateReplicationTaskMessage(
            cdcStartPosition: cdcStartPosition, 
            cdcStartTime: cdcStartTime, 
            cdcStopPosition: cdcStopPosition, 
            migrationType: migrationType, 
            replicationInstanceArn: replicationInstanceArn, 
            replicationTaskIdentifier: replicationTaskIdentifier, 
            replicationTaskSettings: replicationTaskSettings, 
            resourceIdentifier: resourceIdentifier, 
            sourceEndpointArn: sourceEndpointArn, 
            tableMappings: tableMappings, 
            tags: tags, 
            targetEndpointArn: targetEndpointArn, 
            taskData: taskData
        )
        return try await self.createReplicationTask(input, logger: logger)
    }

    /// Deletes the specified certificate.
    @Sendable
    @inlinable
    public func deleteCertificate(_ input: DeleteCertificateMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCertificateResponse {
        try await self.client.execute(
            operation: "DeleteCertificate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified certificate.
    ///
    /// Parameters:
    ///   - certificateArn: The Amazon Resource Name (ARN) of the certificate.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCertificate(
        certificateArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCertificateResponse {
        let input = DeleteCertificateMessage(
            certificateArn: certificateArn
        )
        return try await self.deleteCertificate(input, logger: logger)
    }

    /// Deletes the connection between a replication instance and an endpoint.
    @Sendable
    @inlinable
    public func deleteConnection(_ input: DeleteConnectionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteConnectionResponse {
        try await self.client.execute(
            operation: "DeleteConnection", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the connection between a replication instance and an endpoint.
    ///
    /// Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteConnection(
        endpointArn: String,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteConnectionResponse {
        let input = DeleteConnectionMessage(
            endpointArn: endpointArn, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.deleteConnection(input, logger: logger)
    }

    /// Deletes the specified data migration.
    @Sendable
    @inlinable
    public func deleteDataMigration(_ input: DeleteDataMigrationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDataMigrationResponse {
        try await self.client.execute(
            operation: "DeleteDataMigration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified data migration.
    ///
    /// Parameters:
    ///   - dataMigrationIdentifier: The identifier (name or ARN) of the data migration to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataMigration(
        dataMigrationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDataMigrationResponse {
        let input = DeleteDataMigrationMessage(
            dataMigrationIdentifier: dataMigrationIdentifier
        )
        return try await self.deleteDataMigration(input, logger: logger)
    }

    /// Deletes the specified data provider.  All migration projects associated with the data provider must be deleted or modified before you can delete the data provider.
    @Sendable
    @inlinable
    public func deleteDataProvider(_ input: DeleteDataProviderMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteDataProviderResponse {
        try await self.client.execute(
            operation: "DeleteDataProvider", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified data provider.  All migration projects associated with the data provider must be deleted or modified before you can delete the data provider.
    ///
    /// Parameters:
    ///   - dataProviderIdentifier: The identifier of the data provider to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteDataProvider(
        dataProviderIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteDataProviderResponse {
        let input = DeleteDataProviderMessage(
            dataProviderIdentifier: dataProviderIdentifier
        )
        return try await self.deleteDataProvider(input, logger: logger)
    }

    /// Deletes the specified endpoint.  All tasks associated with the endpoint must be deleted before you can delete the endpoint.
    @Sendable
    @inlinable
    public func deleteEndpoint(_ input: DeleteEndpointMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEndpointResponse {
        try await self.client.execute(
            operation: "DeleteEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified endpoint.  All tasks associated with the endpoint must be deleted before you can delete the endpoint.
    ///
    /// Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEndpoint(
        endpointArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEndpointResponse {
        let input = DeleteEndpointMessage(
            endpointArn: endpointArn
        )
        return try await self.deleteEndpoint(input, logger: logger)
    }

    ///  Deletes an DMS event subscription.
    @Sendable
    @inlinable
    public func deleteEventSubscription(_ input: DeleteEventSubscriptionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteEventSubscriptionResponse {
        try await self.client.execute(
            operation: "DeleteEventSubscription", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Deletes an DMS event subscription.
    ///
    /// Parameters:
    ///   - subscriptionName: The name of the DMS event notification subscription to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteEventSubscription(
        subscriptionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteEventSubscriptionResponse {
        let input = DeleteEventSubscriptionMessage(
            subscriptionName: subscriptionName
        )
        return try await self.deleteEventSubscription(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Deletes the specified Fleet Advisor collector.
    @Sendable
    @inlinable
    public func deleteFleetAdvisorCollector(_ input: DeleteCollectorRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "DeleteFleetAdvisorCollector", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Deletes the specified Fleet Advisor collector.
    ///
    /// Parameters:
    ///   - collectorReferencedId: The reference ID of the Fleet Advisor collector to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFleetAdvisorCollector(
        collectorReferencedId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DeleteCollectorRequest(
            collectorReferencedId: collectorReferencedId
        )
        return try await self.deleteFleetAdvisorCollector(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Deletes the specified Fleet Advisor collector databases.
    @Sendable
    @inlinable
    public func deleteFleetAdvisorDatabases(_ input: DeleteFleetAdvisorDatabasesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFleetAdvisorDatabasesResponse {
        try await self.client.execute(
            operation: "DeleteFleetAdvisorDatabases", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Deletes the specified Fleet Advisor collector databases.
    ///
    /// Parameters:
    ///   - databaseIds: The IDs of the Fleet Advisor collector databases to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFleetAdvisorDatabases(
        databaseIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFleetAdvisorDatabasesResponse {
        let input = DeleteFleetAdvisorDatabasesRequest(
            databaseIds: databaseIds
        )
        return try await self.deleteFleetAdvisorDatabases(input, logger: logger)
    }

    /// Deletes the specified instance profile.  All migration projects associated with the instance profile must be deleted or modified before you can delete the instance profile.
    @Sendable
    @inlinable
    public func deleteInstanceProfile(_ input: DeleteInstanceProfileMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteInstanceProfileResponse {
        try await self.client.execute(
            operation: "DeleteInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified instance profile.  All migration projects associated with the instance profile must be deleted or modified before you can delete the instance profile.
    ///
    /// Parameters:
    ///   - instanceProfileIdentifier: The identifier of the instance profile to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInstanceProfile(
        instanceProfileIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteInstanceProfileResponse {
        let input = DeleteInstanceProfileMessage(
            instanceProfileIdentifier: instanceProfileIdentifier
        )
        return try await self.deleteInstanceProfile(input, logger: logger)
    }

    /// Deletes the specified migration project.  The migration project must be closed before you can delete it.
    @Sendable
    @inlinable
    public func deleteMigrationProject(_ input: DeleteMigrationProjectMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMigrationProjectResponse {
        try await self.client.execute(
            operation: "DeleteMigrationProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified migration project.  The migration project must be closed before you can delete it.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The name or Amazon Resource Name (ARN) of the migration project to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMigrationProject(
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMigrationProjectResponse {
        let input = DeleteMigrationProjectMessage(
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.deleteMigrationProject(input, logger: logger)
    }

    /// Deletes an DMS Serverless replication configuration. This effectively deprovisions any and all replications that use this configuration. You can't delete the configuration for an DMS Serverless replication that is ongoing. You can delete the configuration when the replication is in a non-RUNNING and non-STARTING state.
    @Sendable
    @inlinable
    public func deleteReplicationConfig(_ input: DeleteReplicationConfigMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReplicationConfigResponse {
        try await self.client.execute(
            operation: "DeleteReplicationConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an DMS Serverless replication configuration. This effectively deprovisions any and all replications that use this configuration. You can't delete the configuration for an DMS Serverless replication that is ongoing. You can delete the configuration when the replication is in a non-RUNNING and non-STARTING state.
    ///
    /// Parameters:
    ///   - replicationConfigArn: The replication config to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReplicationConfig(
        replicationConfigArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReplicationConfigResponse {
        let input = DeleteReplicationConfigMessage(
            replicationConfigArn: replicationConfigArn
        )
        return try await self.deleteReplicationConfig(input, logger: logger)
    }

    /// Deletes the specified replication instance.  You must delete any migration tasks that are associated with the replication instance before you can delete it.
    @Sendable
    @inlinable
    public func deleteReplicationInstance(_ input: DeleteReplicationInstanceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReplicationInstanceResponse {
        try await self.client.execute(
            operation: "DeleteReplicationInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified replication instance.  You must delete any migration tasks that are associated with the replication instance before you can delete it.
    ///
    /// Parameters:
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReplicationInstance(
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReplicationInstanceResponse {
        let input = DeleteReplicationInstanceMessage(
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.deleteReplicationInstance(input, logger: logger)
    }

    /// Deletes a subnet group.
    @Sendable
    @inlinable
    public func deleteReplicationSubnetGroup(_ input: DeleteReplicationSubnetGroupMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReplicationSubnetGroupResponse {
        try await self.client.execute(
            operation: "DeleteReplicationSubnetGroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a subnet group.
    ///
    /// Parameters:
    ///   - replicationSubnetGroupIdentifier: The subnet group name of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReplicationSubnetGroup(
        replicationSubnetGroupIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReplicationSubnetGroupResponse {
        let input = DeleteReplicationSubnetGroupMessage(
            replicationSubnetGroupIdentifier: replicationSubnetGroupIdentifier
        )
        return try await self.deleteReplicationSubnetGroup(input, logger: logger)
    }

    /// Deletes the specified replication task.
    @Sendable
    @inlinable
    public func deleteReplicationTask(_ input: DeleteReplicationTaskMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReplicationTaskResponse {
        try await self.client.execute(
            operation: "DeleteReplicationTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified replication task.
    ///
    /// Parameters:
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the replication task to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReplicationTask(
        replicationTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReplicationTaskResponse {
        let input = DeleteReplicationTaskMessage(
            replicationTaskArn: replicationTaskArn
        )
        return try await self.deleteReplicationTask(input, logger: logger)
    }

    /// Deletes the record of a single premigration assessment run. This operation removes all metadata that DMS maintains about this assessment run. However, the operation leaves untouched all information about this assessment run that is stored in your Amazon S3 bucket.
    @Sendable
    @inlinable
    public func deleteReplicationTaskAssessmentRun(_ input: DeleteReplicationTaskAssessmentRunMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteReplicationTaskAssessmentRunResponse {
        try await self.client.execute(
            operation: "DeleteReplicationTaskAssessmentRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the record of a single premigration assessment run. This operation removes all metadata that DMS maintains about this assessment run. However, the operation leaves untouched all information about this assessment run that is stored in your Amazon S3 bucket.
    ///
    /// Parameters:
    ///   - replicationTaskAssessmentRunArn: Amazon Resource Name (ARN) of the premigration assessment run to be deleted.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteReplicationTaskAssessmentRun(
        replicationTaskAssessmentRunArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteReplicationTaskAssessmentRunResponse {
        let input = DeleteReplicationTaskAssessmentRunMessage(
            replicationTaskAssessmentRunArn: replicationTaskAssessmentRunArn
        )
        return try await self.deleteReplicationTaskAssessmentRun(input, logger: logger)
    }

    /// Lists all of the DMS attributes for a customer account. These attributes include DMS quotas for the account and a unique account identifier in a particular DMS region. DMS quotas include a list of resource quotas supported by the account, such as the number of replication instances allowed. The description for each resource quota, includes the quota name, current usage toward that quota, and the quota's maximum value. DMS uses the unique account identifier to name each artifact used by DMS in the given region. This command does not take any parameters.
    @Sendable
    @inlinable
    public func describeAccountAttributes(_ input: DescribeAccountAttributesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeAccountAttributesResponse {
        try await self.client.execute(
            operation: "DescribeAccountAttributes", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all of the DMS attributes for a customer account. These attributes include DMS quotas for the account and a unique account identifier in a particular DMS region. DMS quotas include a list of resource quotas supported by the account, such as the number of replication instances allowed. The description for each resource quota, includes the quota name, current usage toward that quota, and the quota's maximum value. DMS uses the unique account identifier to name each artifact used by DMS in the given region. This command does not take any parameters.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func describeAccountAttributes(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeAccountAttributesResponse {
        let input = DescribeAccountAttributesMessage(
        )
        return try await self.describeAccountAttributes(input, logger: logger)
    }

    /// Provides a list of individual assessments that you can specify for a new premigration assessment run, given one or more parameters. If you specify an existing migration task, this operation provides the default individual assessments you can specify for that task. Otherwise, the specified parameters model elements of a possible migration task on which to base a premigration assessment run. To use these migration task modeling parameters, you must specify an existing replication instance, a source database engine, a target database engine, and a migration type. This combination of parameters potentially limits the default individual assessments available for an assessment run created for a corresponding migration task. If you specify no parameters, this operation provides a list of all possible individual assessments that you can specify for an assessment run. If you specify any one of the task modeling parameters, you must specify all of them or the operation cannot provide a list of individual assessments. The only parameter that you can specify alone is for an existing migration task. The specified task definition then determines the default list of individual assessments that you can specify in an assessment run for the task.
    @Sendable
    @inlinable
    public func describeApplicableIndividualAssessments(_ input: DescribeApplicableIndividualAssessmentsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeApplicableIndividualAssessmentsResponse {
        try await self.client.execute(
            operation: "DescribeApplicableIndividualAssessments", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides a list of individual assessments that you can specify for a new premigration assessment run, given one or more parameters. If you specify an existing migration task, this operation provides the default individual assessments you can specify for that task. Otherwise, the specified parameters model elements of a possible migration task on which to base a premigration assessment run. To use these migration task modeling parameters, you must specify an existing replication instance, a source database engine, a target database engine, and a migration type. This combination of parameters potentially limits the default individual assessments available for an assessment run created for a corresponding migration task. If you specify no parameters, this operation provides a list of all possible individual assessments that you can specify for an assessment run. If you specify any one of the task modeling parameters, you must specify all of them or the operation cannot provide a list of individual assessments. The only parameter that you can specify alone is for an existing migration task. The specified task definition then determines the default list of individual assessments that you can specify in an assessment run for the task.
    ///
    /// Parameters:
    ///   - marker: Optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: Maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - migrationType: Name of the migration type that each provided individual assessment must support.
    ///   - replicationConfigArn: Amazon Resource Name (ARN) of a serverless replication on which you want to base the default list of individual assessments.
    ///   - replicationInstanceArn: ARN of a replication instance on which you want to base the default list of individual assessments.
    ///   - replicationTaskArn: Amazon Resource Name (ARN) of a migration task on which you want to base the default list of individual assessments.
    ///   - sourceEngineName: Name of a database engine that the specified replication instance supports as a source.
    ///   - targetEngineName: Name of a database engine that the specified replication instance supports as a target.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeApplicableIndividualAssessments(
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationType: MigrationTypeValue? = nil,
        replicationConfigArn: String? = nil,
        replicationInstanceArn: String? = nil,
        replicationTaskArn: String? = nil,
        sourceEngineName: String? = nil,
        targetEngineName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeApplicableIndividualAssessmentsResponse {
        let input = DescribeApplicableIndividualAssessmentsMessage(
            marker: marker, 
            maxRecords: maxRecords, 
            migrationType: migrationType, 
            replicationConfigArn: replicationConfigArn, 
            replicationInstanceArn: replicationInstanceArn, 
            replicationTaskArn: replicationTaskArn, 
            sourceEngineName: sourceEngineName, 
            targetEngineName: targetEngineName
        )
        return try await self.describeApplicableIndividualAssessments(input, logger: logger)
    }

    /// Provides a description of the certificate.
    @Sendable
    @inlinable
    public func describeCertificates(_ input: DescribeCertificatesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeCertificatesResponse {
        try await self.client.execute(
            operation: "DescribeCertificates", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides a description of the certificate.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the certificates described in the form of key-value pairs. Valid values are certificate-arn and certificate-id.
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 10
    ///   - logger: Logger use during operation
    @inlinable
    public func describeCertificates(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeCertificatesResponse {
        let input = DescribeCertificatesMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeCertificates(input, logger: logger)
    }

    /// Describes the status of the connections that have been made between the replication instance and an endpoint. Connections are created when you test an endpoint.
    @Sendable
    @inlinable
    public func describeConnections(_ input: DescribeConnectionsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeConnectionsResponse {
        try await self.client.execute(
            operation: "DescribeConnections", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Describes the status of the connections that have been made between the replication instance and an endpoint. Connections are created when you test an endpoint.
    ///
    /// Parameters:
    ///   - filters: The filters applied to the connection. Valid filter names: endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeConnections(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeConnectionsResponse {
        let input = DescribeConnectionsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeConnections(input, logger: logger)
    }

    /// Returns configuration parameters for a schema conversion project.
    @Sendable
    @inlinable
    public func describeConversionConfiguration(_ input: DescribeConversionConfigurationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeConversionConfigurationResponse {
        try await self.client.execute(
            operation: "DescribeConversionConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns configuration parameters for a schema conversion project.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The name or Amazon Resource Name (ARN) for the schema conversion project to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeConversionConfiguration(
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeConversionConfigurationResponse {
        let input = DescribeConversionConfigurationMessage(
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeConversionConfiguration(input, logger: logger)
    }

    /// Returns information about data migrations.
    @Sendable
    @inlinable
    public func describeDataMigrations(_ input: DescribeDataMigrationsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeDataMigrationsResponse {
        try await self.client.execute(
            operation: "DescribeDataMigrations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about data migrations.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the data migrations.
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - withoutStatistics: An option to set to avoid returning information about statistics. Use this to reduce overhead when statistics information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeDataMigrations(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        withoutStatistics: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeDataMigrationsResponse {
        let input = DescribeDataMigrationsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings, 
            withoutStatistics: withoutStatistics
        )
        return try await self.describeDataMigrations(input, logger: logger)
    }

    /// Returns a paginated list of data providers for your account in the current region.
    @Sendable
    @inlinable
    public func describeDataProviders(_ input: DescribeDataProvidersMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeDataProvidersResponse {
        try await self.client.execute(
            operation: "DescribeDataProviders", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of data providers for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the data providers described in the form of key-value pairs. Valid filter names and values: data-provider-identifier, data provider arn or name
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeDataProviders(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeDataProvidersResponse {
        let input = DescribeDataProvidersMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeDataProviders(input, logger: logger)
    }

    /// Returns information about the possible endpoint settings available when you create an endpoint for a specific database engine.
    @Sendable
    @inlinable
    public func describeEndpointSettings(_ input: DescribeEndpointSettingsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEndpointSettingsResponse {
        try await self.client.execute(
            operation: "DescribeEndpointSettings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the possible endpoint settings available when you create an endpoint for a specific database engine.
    ///
    /// Parameters:
    ///   - engineName: The database engine used for your source or target endpoint.
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEndpointSettings(
        engineName: String,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEndpointSettingsResponse {
        let input = DescribeEndpointSettingsMessage(
            engineName: engineName, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeEndpointSettings(input, logger: logger)
    }

    /// Returns information about the type of endpoints available.
    @Sendable
    @inlinable
    public func describeEndpointTypes(_ input: DescribeEndpointTypesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEndpointTypesResponse {
        try await self.client.execute(
            operation: "DescribeEndpointTypes", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the type of endpoints available.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the endpoint types. Valid filter names: engine-name | endpoint-type
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEndpointTypes(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEndpointTypesResponse {
        let input = DescribeEndpointTypesMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeEndpointTypes(input, logger: logger)
    }

    /// Returns information about the endpoints for your account in the current region.
    @Sendable
    @inlinable
    public func describeEndpoints(_ input: DescribeEndpointsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEndpointsResponse {
        try await self.client.execute(
            operation: "DescribeEndpoints", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the endpoints for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the endpoints. Valid filter names: endpoint-arn | endpoint-type | endpoint-id | engine-name
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEndpoints(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEndpointsResponse {
        let input = DescribeEndpointsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeEndpoints(input, logger: logger)
    }

    /// Returns information about the replication instance versions used in the project.
    @Sendable
    @inlinable
    public func describeEngineVersions(_ input: DescribeEngineVersionsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEngineVersionsResponse {
        try await self.client.execute(
            operation: "DescribeEngineVersions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the replication instance versions used in the project.
    ///
    /// Parameters:
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEngineVersions(
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEngineVersionsResponse {
        let input = DescribeEngineVersionsMessage(
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeEngineVersions(input, logger: logger)
    }

    /// Lists categories for all event source types, or, if specified, for a specified source type. You can see a list of the event categories and source types in Working with Events and Notifications in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func describeEventCategories(_ input: DescribeEventCategoriesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEventCategoriesResponse {
        try await self.client.execute(
            operation: "DescribeEventCategories", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists categories for all event source types, or, if specified, for a specified source type. You can see a list of the event categories and source types in Working with Events and Notifications in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the event categories.
    ///   - sourceType:  The type of DMS resource that generates events.  Valid values: replication-instance | replication-task
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEventCategories(
        filters: [Filter]? = nil,
        sourceType: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEventCategoriesResponse {
        let input = DescribeEventCategoriesMessage(
            filters: filters, 
            sourceType: sourceType
        )
        return try await self.describeEventCategories(input, logger: logger)
    }

    /// Lists all the event subscriptions for a customer account. The description of a subscription includes SubscriptionName, SNSTopicARN, CustomerID, SourceType, SourceID, CreationTime, and Status.  If you specify SubscriptionName, this action lists the description for that subscription.
    @Sendable
    @inlinable
    public func describeEventSubscriptions(_ input: DescribeEventSubscriptionsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEventSubscriptionsResponse {
        try await self.client.execute(
            operation: "DescribeEventSubscriptions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all the event subscriptions for a customer account. The description of a subscription includes SubscriptionName, SNSTopicARN, CustomerID, SourceType, SourceID, CreationTime, and Status.  If you specify SubscriptionName, this action lists the description for that subscription.
    ///
    /// Parameters:
    ///   - filters: Filters applied to event subscriptions. Valid filter names: event-subscription-arn | event-subscription-id
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - subscriptionName: The name of the DMS event subscription to be described.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEventSubscriptions(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        subscriptionName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEventSubscriptionsResponse {
        let input = DescribeEventSubscriptionsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            subscriptionName: subscriptionName
        )
        return try await self.describeEventSubscriptions(input, logger: logger)
    }

    ///  Lists events for a given source identifier and source type. You can also specify a start and end time. For more information on DMS events, see Working with Events and Notifications in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func describeEvents(_ input: DescribeEventsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeEventsResponse {
        try await self.client.execute(
            operation: "DescribeEvents", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Lists events for a given source identifier and source type. You can also specify a start and end time. For more information on DMS events, see Working with Events and Notifications in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - duration: The duration of the events to be listed.
    ///   - endTime: The end time for the events to be listed.
    ///   - eventCategories: A list of event categories for the source type that you've chosen.
    ///   - filters: Filters applied to events. The only valid filter is replication-instance-id.
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - sourceIdentifier:  The identifier of an event source.
    ///   - sourceType: The type of DMS resource that generates events. Valid values: replication-instance | replication-task
    ///   - startTime: The start time for the events to be listed.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeEvents(
        duration: Int? = nil,
        endTime: Date? = nil,
        eventCategories: [String]? = nil,
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        sourceIdentifier: String? = nil,
        sourceType: SourceType? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeEventsResponse {
        let input = DescribeEventsMessage(
            duration: duration, 
            endTime: endTime, 
            eventCategories: eventCategories, 
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            sourceIdentifier: sourceIdentifier, 
            sourceType: sourceType, 
            startTime: startTime
        )
        return try await self.describeEvents(input, logger: logger)
    }

    /// Returns a paginated list of extension pack associations for the specified migration project. An extension pack is an add-on module that emulates functions present in a source database that are required when converting objects to the target database.
    @Sendable
    @inlinable
    public func describeExtensionPackAssociations(_ input: DescribeExtensionPackAssociationsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeExtensionPackAssociationsResponse {
        try await self.client.execute(
            operation: "DescribeExtensionPackAssociations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of extension pack associations for the specified migration project. An extension pack is an add-on module that emulates functions present in a source database that are required when converting objects to the target database.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the extension pack associations described in the form of key-value pairs.
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The name or Amazon Resource Name (ARN) for the migration project.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeExtensionPackAssociations(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeExtensionPackAssociationsResponse {
        let input = DescribeExtensionPackAssociationsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeExtensionPackAssociations(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a list of the Fleet Advisor collectors in your account.
    @Sendable
    @inlinable
    public func describeFleetAdvisorCollectors(_ input: DescribeFleetAdvisorCollectorsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFleetAdvisorCollectorsResponse {
        try await self.client.execute(
            operation: "DescribeFleetAdvisorCollectors", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a list of the Fleet Advisor collectors in your account.
    ///
    /// Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those collectors that meet the filter criteria:    collector-referenced-id – The ID of the collector agent, for example d4610ac5-e323-4ad9-bc50-eaf7249dfe9d.    collector-name – The name of the collector agent.   An example is: describe-fleet-advisor-collectors --filter Name="collector-referenced-id",Values="d4610ac5-e323-4ad9-bc50-eaf7249dfe9d"
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - nextToken: If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFleetAdvisorCollectors(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFleetAdvisorCollectorsResponse {
        let input = DescribeFleetAdvisorCollectorsRequest(
            filters: filters, 
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeFleetAdvisorCollectors(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a list of Fleet Advisor databases in your account.
    @Sendable
    @inlinable
    public func describeFleetAdvisorDatabases(_ input: DescribeFleetAdvisorDatabasesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFleetAdvisorDatabasesResponse {
        try await self.client.execute(
            operation: "DescribeFleetAdvisorDatabases", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a list of Fleet Advisor databases in your account.
    ///
    /// Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those databases that meet the filter criteria:     database-id – The ID of the database.    database-name – The name of the database.    database-engine – The name of the database engine.    server-ip-address – The IP address of the database server.    database-ip-address – The IP address of the database.    collector-name – The name of the associated Fleet Advisor collector.   An example is: describe-fleet-advisor-databases --filter Name="database-id",Values="45"
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - nextToken: If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFleetAdvisorDatabases(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFleetAdvisorDatabasesResponse {
        let input = DescribeFleetAdvisorDatabasesRequest(
            filters: filters, 
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeFleetAdvisorDatabases(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Provides descriptions of large-scale assessment (LSA) analyses produced by your Fleet Advisor collectors.
    @Sendable
    @inlinable
    public func describeFleetAdvisorLsaAnalysis(_ input: DescribeFleetAdvisorLsaAnalysisRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFleetAdvisorLsaAnalysisResponse {
        try await self.client.execute(
            operation: "DescribeFleetAdvisorLsaAnalysis", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Provides descriptions of large-scale assessment (LSA) analyses produced by your Fleet Advisor collectors.
    ///
    /// Parameters:
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - nextToken: If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFleetAdvisorLsaAnalysis(
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFleetAdvisorLsaAnalysisResponse {
        let input = DescribeFleetAdvisorLsaAnalysisRequest(
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeFleetAdvisorLsaAnalysis(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Provides descriptions of the schemas discovered by your Fleet Advisor collectors.
    @Sendable
    @inlinable
    public func describeFleetAdvisorSchemaObjectSummary(_ input: DescribeFleetAdvisorSchemaObjectSummaryRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFleetAdvisorSchemaObjectSummaryResponse {
        try await self.client.execute(
            operation: "DescribeFleetAdvisorSchemaObjectSummary", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Provides descriptions of the schemas discovered by your Fleet Advisor collectors.
    ///
    /// Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those schema objects that meet the filter criteria:    schema-id – The ID of the schema, for example d4610ac5-e323-4ad9-bc50-eaf7249dfe9d.   Example: describe-fleet-advisor-schema-object-summary --filter Name="schema-id",Values="50"
    ///   - maxRecords: 
    ///   - nextToken: If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFleetAdvisorSchemaObjectSummary(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFleetAdvisorSchemaObjectSummaryResponse {
        let input = DescribeFleetAdvisorSchemaObjectSummaryRequest(
            filters: filters, 
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeFleetAdvisorSchemaObjectSummary(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a list of schemas detected by Fleet Advisor Collectors in your account.
    @Sendable
    @inlinable
    public func describeFleetAdvisorSchemas(_ input: DescribeFleetAdvisorSchemasRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeFleetAdvisorSchemasResponse {
        try await self.client.execute(
            operation: "DescribeFleetAdvisorSchemas", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a list of schemas detected by Fleet Advisor Collectors in your account.
    ///
    /// Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those schemas that meet the filter criteria:    complexity – The schema's complexity, for example Simple.    database-id – The ID of the schema's database.    database-ip-address – The IP address of the schema's database.    database-name – The name of the schema's database.    database-engine – The name of the schema database's engine.    original-schema-name – The name of the schema's database's main schema.    schema-id – The ID of the schema, for example 15.    schema-name – The name of the schema.    server-ip-address – The IP address of the schema database's server.   An example is: describe-fleet-advisor-schemas --filter Name="schema-id",Values="50"
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - nextToken: If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeFleetAdvisorSchemas(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeFleetAdvisorSchemasResponse {
        let input = DescribeFleetAdvisorSchemasRequest(
            filters: filters, 
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeFleetAdvisorSchemas(input, logger: logger)
    }

    /// Returns a paginated list of instance profiles for your account in the current region.
    @Sendable
    @inlinable
    public func describeInstanceProfiles(_ input: DescribeInstanceProfilesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeInstanceProfilesResponse {
        try await self.client.execute(
            operation: "DescribeInstanceProfiles", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of instance profiles for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the instance profiles described in the form of key-value pairs. Valid filter names and values: instance-profile-identifier, instance profile arn or name
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeInstanceProfiles(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeInstanceProfilesResponse {
        let input = DescribeInstanceProfilesMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeInstanceProfiles(input, logger: logger)
    }

    /// Returns a paginated list of metadata model assessments for your account in the current region.
    @Sendable
    @inlinable
    public func describeMetadataModelAssessments(_ input: DescribeMetadataModelAssessmentsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMetadataModelAssessmentsResponse {
        try await self.client.execute(
            operation: "DescribeMetadataModelAssessments", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of metadata model assessments for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the metadata model assessments described in the form of key-value pairs.
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The name or Amazon Resource Name (ARN) of the migration project.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMetadataModelAssessments(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMetadataModelAssessmentsResponse {
        let input = DescribeMetadataModelAssessmentsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeMetadataModelAssessments(input, logger: logger)
    }

    /// Returns a paginated list of metadata model conversions for a migration project.
    @Sendable
    @inlinable
    public func describeMetadataModelConversions(_ input: DescribeMetadataModelConversionsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMetadataModelConversionsResponse {
        try await self.client.execute(
            operation: "DescribeMetadataModelConversions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of metadata model conversions for a migration project.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the metadata model conversions described in the form of key-value pairs.
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMetadataModelConversions(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMetadataModelConversionsResponse {
        let input = DescribeMetadataModelConversionsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeMetadataModelConversions(input, logger: logger)
    }

    /// Returns a paginated list of metadata model exports.
    @Sendable
    @inlinable
    public func describeMetadataModelExportsAsScript(_ input: DescribeMetadataModelExportsAsScriptMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMetadataModelExportsAsScriptResponse {
        try await self.client.execute(
            operation: "DescribeMetadataModelExportsAsScript", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of metadata model exports.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the metadata model exports described in the form of key-value pairs.
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMetadataModelExportsAsScript(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMetadataModelExportsAsScriptResponse {
        let input = DescribeMetadataModelExportsAsScriptMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeMetadataModelExportsAsScript(input, logger: logger)
    }

    /// Returns a paginated list of metadata model exports.
    @Sendable
    @inlinable
    public func describeMetadataModelExportsToTarget(_ input: DescribeMetadataModelExportsToTargetMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMetadataModelExportsToTargetResponse {
        try await self.client.execute(
            operation: "DescribeMetadataModelExportsToTarget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of metadata model exports.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the metadata model exports described in the form of key-value pairs.
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMetadataModelExportsToTarget(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMetadataModelExportsToTargetResponse {
        let input = DescribeMetadataModelExportsToTargetMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeMetadataModelExportsToTarget(input, logger: logger)
    }

    /// Returns a paginated list of metadata model imports.
    @Sendable
    @inlinable
    public func describeMetadataModelImports(_ input: DescribeMetadataModelImportsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMetadataModelImportsResponse {
        try await self.client.execute(
            operation: "DescribeMetadataModelImports", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of metadata model imports.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the metadata model imports described in the form of key-value pairs.
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: A paginated list of metadata model imports.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMetadataModelImports(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMetadataModelImportsResponse {
        let input = DescribeMetadataModelImportsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.describeMetadataModelImports(input, logger: logger)
    }

    /// Returns a paginated list of migration projects for your account in the current region.
    @Sendable
    @inlinable
    public func describeMigrationProjects(_ input: DescribeMigrationProjectsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeMigrationProjectsResponse {
        try await self.client.execute(
            operation: "DescribeMigrationProjects", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of migration projects for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the migration projects described in the form of key-value pairs. Valid filter names and values:   instance-profile-identifier, instance profile arn or name   data-provider-identifier, data provider arn or name   migration-project-identifier, migration project arn or name
    ///   - marker: Specifies the unique pagination token that makes it possible to display the next page of results.  If this parameter is specified, the response includes only records beyond the marker, up to the  value specified by MaxRecords. If Marker is returned by a previous response, there are more results available.  The value of Marker is a unique pagination token for each page. To retrieve the next page,  make the call again using the returned token and keeping all other arguments unchanged.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeMigrationProjects(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeMigrationProjectsResponse {
        let input = DescribeMigrationProjectsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeMigrationProjects(input, logger: logger)
    }

    /// Returns information about the replication instance types that can be created in the specified region.
    @Sendable
    @inlinable
    public func describeOrderableReplicationInstances(_ input: DescribeOrderableReplicationInstancesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeOrderableReplicationInstancesResponse {
        try await self.client.execute(
            operation: "DescribeOrderableReplicationInstances", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the replication instance types that can be created in the specified region.
    ///
    /// Parameters:
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeOrderableReplicationInstances(
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeOrderableReplicationInstancesResponse {
        let input = DescribeOrderableReplicationInstancesMessage(
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeOrderableReplicationInstances(input, logger: logger)
    }

    /// Returns a list of upcoming maintenance events for replication instances in your account in the current Region.
    @Sendable
    @inlinable
    public func describePendingMaintenanceActions(_ input: DescribePendingMaintenanceActionsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribePendingMaintenanceActionsResponse {
        try await self.client.execute(
            operation: "DescribePendingMaintenanceActions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of upcoming maintenance events for replication instances in your account in the current Region.
    ///
    /// Parameters:
    ///   - filters: 
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describePendingMaintenanceActions(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        replicationInstanceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribePendingMaintenanceActionsResponse {
        let input = DescribePendingMaintenanceActionsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.describePendingMaintenanceActions(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a paginated list of limitations for recommendations of target Amazon Web Services engines.
    @Sendable
    @inlinable
    public func describeRecommendationLimitations(_ input: DescribeRecommendationLimitationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeRecommendationLimitationsResponse {
        try await self.client.execute(
            operation: "DescribeRecommendationLimitations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a paginated list of limitations for recommendations of target Amazon Web Services engines.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the limitations described in the form of key-value pairs. Valid filter names: database-id | engine-name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, Fleet Advisor includes a pagination token in the response so that you can retrieve the remaining results.
    ///   - nextToken: Specifies the unique pagination token that makes it possible to display the next page of results. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords. If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeRecommendationLimitations(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeRecommendationLimitationsResponse {
        let input = DescribeRecommendationLimitationsRequest(
            filters: filters, 
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeRecommendationLimitations(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a paginated list of target engine recommendations for your source databases.
    @Sendable
    @inlinable
    public func describeRecommendations(_ input: DescribeRecommendationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeRecommendationsResponse {
        try await self.client.execute(
            operation: "DescribeRecommendations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Returns a paginated list of target engine recommendations for your source databases.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the target engine recommendations described in the form of key-value pairs. Valid filter names: database-id | engine-name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, Fleet Advisor includes a pagination token in the response so that you can retrieve the remaining results.
    ///   - nextToken: Specifies the unique pagination token that makes it possible to display the next page of results. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords. If NextToken is returned by a previous response, there are more results available. The value of NextToken is a unique pagination token for each page. Make the call again using the returned token to retrieve the next page. Keep all other arguments unchanged.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeRecommendations(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeRecommendationsResponse {
        let input = DescribeRecommendationsRequest(
            filters: filters, 
            maxRecords: maxRecords, 
            nextToken: nextToken
        )
        return try await self.describeRecommendations(input, logger: logger)
    }

    /// Returns the status of the RefreshSchemas operation.
    @Sendable
    @inlinable
    public func describeRefreshSchemasStatus(_ input: DescribeRefreshSchemasStatusMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeRefreshSchemasStatusResponse {
        try await self.client.execute(
            operation: "DescribeRefreshSchemasStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the status of the RefreshSchemas operation.
    ///
    /// Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeRefreshSchemasStatus(
        endpointArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeRefreshSchemasStatusResponse {
        let input = DescribeRefreshSchemasStatusMessage(
            endpointArn: endpointArn
        )
        return try await self.describeRefreshSchemasStatus(input, logger: logger)
    }

    /// Returns one or more existing DMS Serverless replication configurations as a list of structures.
    @Sendable
    @inlinable
    public func describeReplicationConfigs(_ input: DescribeReplicationConfigsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationConfigsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationConfigs", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns one or more existing DMS Serverless replication configurations as a list of structures.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the replication configs.
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationConfigs(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationConfigsResponse {
        let input = DescribeReplicationConfigsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeReplicationConfigs(input, logger: logger)
    }

    /// Returns information about the task logs for the specified task.
    @Sendable
    @inlinable
    public func describeReplicationInstanceTaskLogs(_ input: DescribeReplicationInstanceTaskLogsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationInstanceTaskLogsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationInstanceTaskLogs", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the task logs for the specified task.
    ///
    /// Parameters:
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationInstanceTaskLogs(
        marker: String? = nil,
        maxRecords: Int? = nil,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationInstanceTaskLogsResponse {
        let input = DescribeReplicationInstanceTaskLogsMessage(
            marker: marker, 
            maxRecords: maxRecords, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.describeReplicationInstanceTaskLogs(input, logger: logger)
    }

    /// Returns information about replication instances for your account in the current region.
    @Sendable
    @inlinable
    public func describeReplicationInstances(_ input: DescribeReplicationInstancesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationInstancesResponse {
        try await self.client.execute(
            operation: "DescribeReplicationInstances", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about replication instances for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to replication instances. Valid filter names: replication-instance-arn | replication-instance-id | replication-instance-class | engine-version
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationInstances(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationInstancesResponse {
        let input = DescribeReplicationInstancesMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeReplicationInstances(input, logger: logger)
    }

    /// Returns information about the replication subnet groups.
    @Sendable
    @inlinable
    public func describeReplicationSubnetGroups(_ input: DescribeReplicationSubnetGroupsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationSubnetGroupsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationSubnetGroups", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the replication subnet groups.
    ///
    /// Parameters:
    ///   - filters: Filters applied to replication subnet groups. Valid filter names: replication-subnet-group-id
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationSubnetGroups(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationSubnetGroupsResponse {
        let input = DescribeReplicationSubnetGroupsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeReplicationSubnetGroups(input, logger: logger)
    }

    /// Returns table and schema statistics for one or more provisioned replications that use a given DMS Serverless replication configuration.
    @Sendable
    @inlinable
    public func describeReplicationTableStatistics(_ input: DescribeReplicationTableStatisticsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationTableStatisticsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationTableStatistics", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns table and schema statistics for one or more provisioned replications that use a given DMS Serverless replication configuration.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the replication table statistics.
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - replicationConfigArn: The replication config to describe.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationTableStatistics(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        replicationConfigArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationTableStatisticsResponse {
        let input = DescribeReplicationTableStatisticsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            replicationConfigArn: replicationConfigArn
        )
        return try await self.describeReplicationTableStatistics(input, logger: logger)
    }

    /// Returns the task assessment results from the Amazon S3 bucket that DMS creates in your Amazon Web Services account. This action always returns the latest results. For more information about DMS task assessments, see Creating a task assessment report in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func describeReplicationTaskAssessmentResults(_ input: DescribeReplicationTaskAssessmentResultsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationTaskAssessmentResultsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationTaskAssessmentResults", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the task assessment results from the Amazon S3 bucket that DMS creates in your Amazon Web Services account. This action always returns the latest results. For more information about DMS task assessments, see Creating a task assessment report in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) string that uniquely identifies the task. When this input parameter is specified, the API returns only one result and ignore the values of the MaxRecords and Marker parameters.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationTaskAssessmentResults(
        marker: String? = nil,
        maxRecords: Int? = nil,
        replicationTaskArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationTaskAssessmentResultsResponse {
        let input = DescribeReplicationTaskAssessmentResultsMessage(
            marker: marker, 
            maxRecords: maxRecords, 
            replicationTaskArn: replicationTaskArn
        )
        return try await self.describeReplicationTaskAssessmentResults(input, logger: logger)
    }

    /// Returns a paginated list of premigration assessment runs based on filter settings. These filter settings can specify a combination of premigration assessment runs, migration tasks, replication instances, and assessment run status values.  This operation doesn't return information about individual assessments. For this information, see the DescribeReplicationTaskIndividualAssessments operation.
    @Sendable
    @inlinable
    public func describeReplicationTaskAssessmentRuns(_ input: DescribeReplicationTaskAssessmentRunsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationTaskAssessmentRunsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationTaskAssessmentRuns", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of premigration assessment runs based on filter settings. These filter settings can specify a combination of premigration assessment runs, migration tasks, replication instances, and assessment run status values.  This operation doesn't return information about individual assessments. For this information, see the DescribeReplicationTaskIndividualAssessments operation.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the premigration assessment runs described in the form of key-value pairs. Valid filter names: replication-task-assessment-run-arn, replication-task-arn, replication-instance-arn, status
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationTaskAssessmentRuns(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationTaskAssessmentRunsResponse {
        let input = DescribeReplicationTaskAssessmentRunsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeReplicationTaskAssessmentRuns(input, logger: logger)
    }

    /// Returns a paginated list of individual assessments based on filter settings. These filter settings can specify a combination of premigration assessment runs, migration tasks, and assessment status values.
    @Sendable
    @inlinable
    public func describeReplicationTaskIndividualAssessments(_ input: DescribeReplicationTaskIndividualAssessmentsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationTaskIndividualAssessmentsResponse {
        try await self.client.execute(
            operation: "DescribeReplicationTaskIndividualAssessments", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a paginated list of individual assessments based on filter settings. These filter settings can specify a combination of premigration assessment runs, migration tasks, and assessment status values.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the individual assessments described in the form of key-value pairs. Valid filter names: replication-task-assessment-run-arn, replication-task-arn, status
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationTaskIndividualAssessments(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationTaskIndividualAssessmentsResponse {
        let input = DescribeReplicationTaskIndividualAssessmentsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeReplicationTaskIndividualAssessments(input, logger: logger)
    }

    /// Returns information about replication tasks for your account in the current region.
    @Sendable
    @inlinable
    public func describeReplicationTasks(_ input: DescribeReplicationTasksMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationTasksResponse {
        try await self.client.execute(
            operation: "DescribeReplicationTasks", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about replication tasks for your account in the current region.
    ///
    /// Parameters:
    ///   - filters: Filters applied to replication tasks. Valid filter names: replication-task-arn | replication-task-id | migration-type | endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplicationTasks(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationTasksResponse {
        let input = DescribeReplicationTasksMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings
        )
        return try await self.describeReplicationTasks(input, logger: logger)
    }

    /// Provides details on replication progress by returning status information for one or more provisioned DMS Serverless replications.
    @Sendable
    @inlinable
    public func describeReplications(_ input: DescribeReplicationsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeReplicationsResponse {
        try await self.client.execute(
            operation: "DescribeReplications", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Provides details on replication progress by returning status information for one or more provisioned DMS Serverless replications.
    ///
    /// Parameters:
    ///   - filters: Filters applied to the replications. Valid filter names: replication-config-arn | replication-config-id
    ///   - marker: An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeReplications(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeReplicationsResponse {
        let input = DescribeReplicationsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeReplications(input, logger: logger)
    }

    /// Returns information about the schema for the specified endpoint.
    @Sendable
    @inlinable
    public func describeSchemas(_ input: DescribeSchemasMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeSchemasResponse {
        try await self.client.execute(
            operation: "DescribeSchemas", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about the schema for the specified endpoint.
    ///
    /// Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeSchemas(
        endpointArn: String,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeSchemasResponse {
        let input = DescribeSchemasMessage(
            endpointArn: endpointArn, 
            marker: marker, 
            maxRecords: maxRecords
        )
        return try await self.describeSchemas(input, logger: logger)
    }

    /// Returns table statistics on the database migration task, including table name, rows inserted, rows updated, and rows deleted. Note that the "last updated" column the DMS console only indicates the time that DMS last updated the table statistics record for a table. It does not indicate the time of the last update to the table.
    @Sendable
    @inlinable
    public func describeTableStatistics(_ input: DescribeTableStatisticsMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeTableStatisticsResponse {
        try await self.client.execute(
            operation: "DescribeTableStatistics", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns table statistics on the database migration task, including table name, rows inserted, rows updated, and rows deleted. Note that the "last updated" column the DMS console only indicates the time that DMS last updated the table statistics record for a table. It does not indicate the time of the last update to the table.
    ///
    /// Parameters:
    ///   - filters: Filters applied to table statistics. Valid filter names: schema-name | table-name | table-state A combination of filters creates an AND condition where each record matches all specified filters.
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 500.
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the replication task.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeTableStatistics(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        replicationTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeTableStatisticsResponse {
        let input = DescribeTableStatisticsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            replicationTaskArn: replicationTaskArn
        )
        return try await self.describeTableStatistics(input, logger: logger)
    }

    /// Saves a copy of a database migration assessment report to your Amazon S3 bucket. DMS can save your assessment report as a comma-separated value (CSV) or a PDF file.
    @Sendable
    @inlinable
    public func exportMetadataModelAssessment(_ input: ExportMetadataModelAssessmentMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ExportMetadataModelAssessmentResponse {
        try await self.client.execute(
            operation: "ExportMetadataModelAssessment", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Saves a copy of a database migration assessment report to your Amazon S3 bucket. DMS can save your assessment report as a comma-separated value (CSV) or a PDF file.
    ///
    /// Parameters:
    ///   - assessmentReportTypes: The file format of the assessment file.
    ///   - fileName: The name of the assessment file to create in your Amazon S3 bucket.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - selectionRules: A value that specifies the database objects to assess.
    ///   - logger: Logger use during operation
    @inlinable
    public func exportMetadataModelAssessment(
        assessmentReportTypes: [AssessmentReportType]? = nil,
        fileName: String? = nil,
        migrationProjectIdentifier: String,
        selectionRules: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ExportMetadataModelAssessmentResponse {
        let input = ExportMetadataModelAssessmentMessage(
            assessmentReportTypes: assessmentReportTypes, 
            fileName: fileName, 
            migrationProjectIdentifier: migrationProjectIdentifier, 
            selectionRules: selectionRules
        )
        return try await self.exportMetadataModelAssessment(input, logger: logger)
    }

    /// Uploads the specified certificate.
    @Sendable
    @inlinable
    public func importCertificate(_ input: ImportCertificateMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ImportCertificateResponse {
        try await self.client.execute(
            operation: "ImportCertificate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Uploads the specified certificate.
    ///
    /// Parameters:
    ///   - certificateIdentifier: A customer-assigned name for the certificate. Identifiers must begin with a letter and must contain only ASCII letters, digits, and hyphens. They can't end with a hyphen or contain two consecutive hyphens.
    ///   - certificatePem: The contents of a .pem file, which contains an X.509 certificate.
    ///   - certificateWallet: The location of an imported Oracle Wallet certificate for use with SSL. Provide the name of a .sso file using the fileb:// prefix. You can't provide the certificate inline. Example: filebase64("${path.root}/rds-ca-2019-root.sso")
    ///   - tags: The tags associated with the certificate.
    ///   - logger: Logger use during operation
    @inlinable
    public func importCertificate(
        certificateIdentifier: String,
        certificatePem: String? = nil,
        certificateWallet: AWSBase64Data? = nil,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ImportCertificateResponse {
        let input = ImportCertificateMessage(
            certificateIdentifier: certificateIdentifier, 
            certificatePem: certificatePem, 
            certificateWallet: certificateWallet, 
            tags: tags
        )
        return try await self.importCertificate(input, logger: logger)
    }

    /// Lists all metadata tags attached to an DMS resource, including replication instance, endpoint, subnet group, and migration task. For more information, see  Tag  data type description.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all metadata tags attached to an DMS resource, including replication instance, endpoint, subnet group, and migration task. For more information, see  Tag  data type description.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) string that uniquely identifies the DMS resource to list tags for. This returns a list of keys (names of tags) created for the resource and their associated tag values.
    ///   - resourceArnList: List of ARNs that identify multiple DMS resources that you want to list tags for. This returns a list of keys (tag names) and their associated tag values. It also returns each tag's associated ResourceArn value, which is the ARN of the resource for which each listed tag is created.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String? = nil,
        resourceArnList: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceMessage(
            resourceArn: resourceArn, 
            resourceArnList: resourceArnList
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Modifies the specified schema conversion configuration using the provided parameters.
    @Sendable
    @inlinable
    public func modifyConversionConfiguration(_ input: ModifyConversionConfigurationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyConversionConfigurationResponse {
        try await self.client.execute(
            operation: "ModifyConversionConfiguration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified schema conversion configuration using the provided parameters.
    ///
    /// Parameters:
    ///   - conversionConfiguration: The new conversion configuration.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyConversionConfiguration(
        conversionConfiguration: String,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyConversionConfigurationResponse {
        let input = ModifyConversionConfigurationMessage(
            conversionConfiguration: conversionConfiguration, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.modifyConversionConfiguration(input, logger: logger)
    }

    /// Modifies an existing DMS data migration.
    @Sendable
    @inlinable
    public func modifyDataMigration(_ input: ModifyDataMigrationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyDataMigrationResponse {
        try await self.client.execute(
            operation: "ModifyDataMigration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies an existing DMS data migration.
    ///
    /// Parameters:
    ///   - dataMigrationIdentifier: The identifier (name or ARN) of the data migration to modify.
    ///   - dataMigrationName: The new name for the data migration.
    ///   - dataMigrationType: The new migration type for the data migration.
    ///   - enableCloudwatchLogs: Whether to enable Cloudwatch logs for the data migration.
    ///   - numberOfJobs: The number of parallel jobs that trigger parallel threads to unload the tables from the source, and then load them to the target.
    ///   - selectionRules: A JSON-formatted string that defines what objects to include and exclude from the migration.
    ///   - serviceAccessRoleArn: The new service access role ARN for the data migration.
    ///   - sourceDataSettings: The new information about the source data provider for the data migration.
    ///   - targetDataSettings: The new information about the target data provider for the data migration.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyDataMigration(
        dataMigrationIdentifier: String,
        dataMigrationName: String? = nil,
        dataMigrationType: MigrationTypeValue? = nil,
        enableCloudwatchLogs: Bool? = nil,
        numberOfJobs: Int? = nil,
        selectionRules: String? = nil,
        serviceAccessRoleArn: String? = nil,
        sourceDataSettings: [SourceDataSetting]? = nil,
        targetDataSettings: [TargetDataSetting]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyDataMigrationResponse {
        let input = ModifyDataMigrationMessage(
            dataMigrationIdentifier: dataMigrationIdentifier, 
            dataMigrationName: dataMigrationName, 
            dataMigrationType: dataMigrationType, 
            enableCloudwatchLogs: enableCloudwatchLogs, 
            numberOfJobs: numberOfJobs, 
            selectionRules: selectionRules, 
            serviceAccessRoleArn: serviceAccessRoleArn, 
            sourceDataSettings: sourceDataSettings, 
            targetDataSettings: targetDataSettings
        )
        return try await self.modifyDataMigration(input, logger: logger)
    }

    /// Modifies the specified data provider using the provided settings.  You must remove the data provider from all migration projects before you can modify it.
    @Sendable
    @inlinable
    public func modifyDataProvider(_ input: ModifyDataProviderMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyDataProviderResponse {
        try await self.client.execute(
            operation: "ModifyDataProvider", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified data provider using the provided settings.  You must remove the data provider from all migration projects before you can modify it.
    ///
    /// Parameters:
    ///   - dataProviderIdentifier: The identifier of the data provider. Identifiers must begin with a letter  and must contain only ASCII letters, digits, and hyphens. They can't end with  a hyphen, or contain two consecutive hyphens.
    ///   - dataProviderName: The name of the data provider.
    ///   - description: A user-friendly description of the data provider.
    ///   - engine: The type of database engine for the data provider. Valid values include "aurora",  "aurora-postgresql", "mysql", "oracle", "postgres",  "sqlserver", redshift, mariadb, mongodb, db2, db2-zos and docdb. A value of "aurora" represents Amazon Aurora MySQL-Compatible Edition.
    ///   - exactSettings: If this attribute is Y, the current call to ModifyDataProvider replaces all existing data provider settings with the exact settings that you specify in this call. If this attribute is N, the current call to ModifyDataProvider does two things:    It replaces any data provider settings that already exist with new values,  for settings with the same names.   It creates new data provider settings that you specify in the call,  for settings with different names.
    ///   - settings: The settings in JSON format for a data provider.
    ///   - virtual: Indicates whether the data provider is virtual.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyDataProvider(
        dataProviderIdentifier: String,
        dataProviderName: String? = nil,
        description: String? = nil,
        engine: String? = nil,
        exactSettings: Bool? = nil,
        settings: DataProviderSettings? = nil,
        virtual: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyDataProviderResponse {
        let input = ModifyDataProviderMessage(
            dataProviderIdentifier: dataProviderIdentifier, 
            dataProviderName: dataProviderName, 
            description: description, 
            engine: engine, 
            exactSettings: exactSettings, 
            settings: settings, 
            virtual: virtual
        )
        return try await self.modifyDataProvider(input, logger: logger)
    }

    /// Modifies the specified endpoint.  For a MySQL source or target endpoint, don't explicitly specify the database using the DatabaseName request parameter on the ModifyEndpoint API call. Specifying DatabaseName when you modify a MySQL endpoint replicates all the task tables to this single database. For MySQL endpoints, you specify the database only when you specify the schema in the table-mapping rules of the DMS task.
    @Sendable
    @inlinable
    public func modifyEndpoint(_ input: ModifyEndpointMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyEndpointResponse {
        try await self.client.execute(
            operation: "ModifyEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified endpoint.  For a MySQL source or target endpoint, don't explicitly specify the database using the DatabaseName request parameter on the ModifyEndpoint API call. Specifying DatabaseName when you modify a MySQL endpoint replicates all the task tables to this single database. For MySQL endpoints, you specify the database only when you specify the schema in the table-mapping rules of the DMS task.
    ///
    /// Parameters:
    ///   - certificateArn: The Amazon Resource Name (ARN) of the certificate used for SSL connection.
    ///   - databaseName: The name of the endpoint database. For a MySQL source or target endpoint, do not specify DatabaseName.
    ///   - dmsTransferSettings: The settings in JSON format for the DMS transfer type of source endpoint.  Attributes include the following:   serviceAccessRoleArn - The Amazon Resource Name (ARN) used by the service access IAM role. The role must allow the iam:PassRole action.   BucketName - The name of the S3 bucket to use.   Shorthand syntax for these settings is as follows: ServiceAccessRoleArn=string ,BucketName=string  JSON syntax for these settings is as follows: { "ServiceAccessRoleArn": "string", "BucketName": "string"}
    ///   - docDbSettings: Settings in JSON format for the source DocumentDB endpoint. For more information about the available settings, see the configuration properties section in  Using DocumentDB as a Target for Database Migration Service  in the Database Migration Service User Guide.
    ///   - dynamoDbSettings: Settings in JSON format for the target Amazon DynamoDB endpoint. For information about other available settings, see Using Object Mapping to Migrate Data to DynamoDB in the Database Migration Service User Guide.
    ///   - elasticsearchSettings: Settings in JSON format for the target OpenSearch endpoint. For more information about the available settings, see Extra Connection Attributes When Using OpenSearch as a Target for DMS in the Database Migration Service User Guide.
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - endpointIdentifier: The database endpoint identifier. Identifiers must begin with a letter and must contain only ASCII letters, digits, and hyphens. They can't end with a hyphen or contain two consecutive hyphens.
    ///   - endpointType: The type of endpoint. Valid values are source and target.
    ///   - engineName: The database engine name. Valid values, depending on the EndpointType, include "mysql", "oracle", "postgres", "mariadb", "aurora", "aurora-postgresql", "redshift", "s3", "db2", "db2-zos", "azuredb", "sybase", "dynamodb", "mongodb", "kinesis", "kafka", "elasticsearch", "documentdb", "sqlserver", "neptune", and "babelfish".
    ///   - exactSettings: If this attribute is Y, the current call to ModifyEndpoint replaces all existing endpoint settings with the exact settings that you specify in this call. If this attribute is N, the current call to ModifyEndpoint does two things:    It replaces any endpoint settings that already exist with new values, for settings with the same names.   It creates new endpoint settings that you specify in the call, for settings with different names.    For example, if you call create-endpoint ... --endpoint-settings '{"a":1}' ..., the endpoint has the following endpoint settings: '{"a":1}'. If you then call modify-endpoint ... --endpoint-settings '{"b":2}' ... for the same endpoint, the endpoint has the following settings: '{"a":1,"b":2}'.  However, suppose that you follow this with a call to modify-endpoint ... --endpoint-settings '{"b":2}' --exact-settings ... for that same endpoint again. Then the endpoint has the following settings: '{"b":2}'. All existing settings are replaced with the exact settings that you specify.
    ///   - externalTableDefinition: The external table definition.
    ///   - extraConnectionAttributes: Additional attributes associated with the connection. To reset this parameter, pass the empty string ("") as an argument.
    ///   - gcpMySQLSettings: Settings in JSON format for the source GCP MySQL endpoint.
    ///   - ibmDb2Settings: Settings in JSON format for the source IBM Db2 LUW endpoint. For information about other available settings, see Extra connection attributes when using Db2 LUW as a source for DMS in the Database Migration Service User Guide.
    ///   - kafkaSettings: Settings in JSON format for the target Apache Kafka endpoint. For more information about the available settings, see Using object mapping to migrate data to a Kafka topic in the Database Migration Service User Guide.
    ///   - kinesisSettings: Settings in JSON format for the target endpoint for Amazon Kinesis Data Streams. For more information about the available settings, see Using object mapping to migrate data to a Kinesis data stream in the Database Migration Service User Guide.
    ///   - microsoftSQLServerSettings: Settings in JSON format for the source and target Microsoft SQL Server endpoint. For information about other available settings, see Extra connection attributes when using SQL Server as a source for DMS and Extra connection attributes when using SQL Server as a target for DMS in the Database Migration Service User Guide.
    ///   - mongoDbSettings: Settings in JSON format for the source MongoDB endpoint. For more information about the available settings, see the configuration properties section in Endpoint configuration settings when using MongoDB as a source for Database Migration Service in the Database Migration Service User Guide.
    ///   - mySQLSettings: Settings in JSON format for the source and target MySQL endpoint. For information about other available settings, see Extra connection attributes when using MySQL as a source for DMS and Extra connection attributes when using a MySQL-compatible database as a target for DMS in the Database Migration Service User Guide.
    ///   - neptuneSettings: Settings in JSON format for the target Amazon Neptune endpoint. For more information about the available settings, see Specifying graph-mapping rules using Gremlin and R2RML for Amazon Neptune as a target in the Database Migration Service User Guide.
    ///   - oracleSettings: Settings in JSON format for the source and target Oracle endpoint. For information about other available settings, see Extra connection attributes when using Oracle as a source for DMS and  Extra connection attributes when using Oracle as a target for DMS in the Database Migration Service User Guide.
    ///   - password: The password to be used to login to the endpoint database.
    ///   - port: The port used by the endpoint database.
    ///   - postgreSQLSettings: Settings in JSON format for the source and target PostgreSQL endpoint. For information about other available settings, see Extra connection attributes when using PostgreSQL as a source for DMS and Extra connection attributes when using PostgreSQL as a target for DMS in the Database Migration Service User Guide.
    ///   - redisSettings: Settings in JSON format for the Redis target endpoint.
    ///   - redshiftSettings: 
    ///   - s3Settings: Settings in JSON format for the target Amazon S3 endpoint. For more information about the available settings, see Extra Connection Attributes When Using Amazon S3 as a Target for DMS in the Database Migration Service User Guide.
    ///   - serverName: The name of the server where the endpoint database resides.
    ///   - serviceAccessRoleArn:  The Amazon Resource Name (ARN) for the IAM role you want to use to modify the endpoint. The role must allow the iam:PassRole action.
    ///   - sslMode: The SSL mode used to connect to the endpoint. The default value is none.
    ///   - sybaseSettings: Settings in JSON format for the source and target SAP ASE endpoint. For information about other available settings, see Extra connection attributes when using SAP ASE as a source for DMS and Extra connection attributes when using SAP ASE as a target for DMS in the Database Migration Service User Guide.
    ///   - timestreamSettings: Settings in JSON format for the target Amazon Timestream endpoint.
    ///   - username: The user name to be used to login to the endpoint database.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyEndpoint(
        certificateArn: String? = nil,
        databaseName: String? = nil,
        dmsTransferSettings: DmsTransferSettings? = nil,
        docDbSettings: DocDbSettings? = nil,
        dynamoDbSettings: DynamoDbSettings? = nil,
        elasticsearchSettings: ElasticsearchSettings? = nil,
        endpointArn: String,
        endpointIdentifier: String? = nil,
        endpointType: ReplicationEndpointTypeValue? = nil,
        engineName: String? = nil,
        exactSettings: Bool? = nil,
        externalTableDefinition: String? = nil,
        extraConnectionAttributes: String? = nil,
        gcpMySQLSettings: GcpMySQLSettings? = nil,
        ibmDb2Settings: IBMDb2Settings? = nil,
        kafkaSettings: KafkaSettings? = nil,
        kinesisSettings: KinesisSettings? = nil,
        microsoftSQLServerSettings: MicrosoftSQLServerSettings? = nil,
        mongoDbSettings: MongoDbSettings? = nil,
        mySQLSettings: MySQLSettings? = nil,
        neptuneSettings: NeptuneSettings? = nil,
        oracleSettings: OracleSettings? = nil,
        password: String? = nil,
        port: Int? = nil,
        postgreSQLSettings: PostgreSQLSettings? = nil,
        redisSettings: RedisSettings? = nil,
        redshiftSettings: RedshiftSettings? = nil,
        s3Settings: S3Settings? = nil,
        serverName: String? = nil,
        serviceAccessRoleArn: String? = nil,
        sslMode: DmsSslModeValue? = nil,
        sybaseSettings: SybaseSettings? = nil,
        timestreamSettings: TimestreamSettings? = nil,
        username: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyEndpointResponse {
        let input = ModifyEndpointMessage(
            certificateArn: certificateArn, 
            databaseName: databaseName, 
            dmsTransferSettings: dmsTransferSettings, 
            docDbSettings: docDbSettings, 
            dynamoDbSettings: dynamoDbSettings, 
            elasticsearchSettings: elasticsearchSettings, 
            endpointArn: endpointArn, 
            endpointIdentifier: endpointIdentifier, 
            endpointType: endpointType, 
            engineName: engineName, 
            exactSettings: exactSettings, 
            externalTableDefinition: externalTableDefinition, 
            extraConnectionAttributes: extraConnectionAttributes, 
            gcpMySQLSettings: gcpMySQLSettings, 
            ibmDb2Settings: ibmDb2Settings, 
            kafkaSettings: kafkaSettings, 
            kinesisSettings: kinesisSettings, 
            microsoftSQLServerSettings: microsoftSQLServerSettings, 
            mongoDbSettings: mongoDbSettings, 
            mySQLSettings: mySQLSettings, 
            neptuneSettings: neptuneSettings, 
            oracleSettings: oracleSettings, 
            password: password, 
            port: port, 
            postgreSQLSettings: postgreSQLSettings, 
            redisSettings: redisSettings, 
            redshiftSettings: redshiftSettings, 
            s3Settings: s3Settings, 
            serverName: serverName, 
            serviceAccessRoleArn: serviceAccessRoleArn, 
            sslMode: sslMode, 
            sybaseSettings: sybaseSettings, 
            timestreamSettings: timestreamSettings, 
            username: username
        )
        return try await self.modifyEndpoint(input, logger: logger)
    }

    /// Modifies an existing DMS event notification subscription.
    @Sendable
    @inlinable
    public func modifyEventSubscription(_ input: ModifyEventSubscriptionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyEventSubscriptionResponse {
        try await self.client.execute(
            operation: "ModifyEventSubscription", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies an existing DMS event notification subscription.
    ///
    /// Parameters:
    ///   - enabled:  A Boolean value; set to true to activate the subscription.
    ///   - eventCategories:  A list of event categories for a source type that you want to subscribe to. Use the DescribeEventCategories action to see a list of event categories.
    ///   - snsTopicArn:  The Amazon Resource Name (ARN) of the Amazon SNS topic created for event notification. The ARN is created by Amazon SNS when you create a topic and subscribe to it.
    ///   - sourceType:  The type of DMS resource that generates the events you want to subscribe to.  Valid values: replication-instance | replication-task
    ///   - subscriptionName: The name of the DMS event notification subscription to be modified.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyEventSubscription(
        enabled: Bool? = nil,
        eventCategories: [String]? = nil,
        snsTopicArn: String? = nil,
        sourceType: String? = nil,
        subscriptionName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyEventSubscriptionResponse {
        let input = ModifyEventSubscriptionMessage(
            enabled: enabled, 
            eventCategories: eventCategories, 
            snsTopicArn: snsTopicArn, 
            sourceType: sourceType, 
            subscriptionName: subscriptionName
        )
        return try await self.modifyEventSubscription(input, logger: logger)
    }

    /// Modifies the specified instance profile using the provided parameters.  All migration projects associated with the instance profile must be deleted or modified before you can modify the instance profile.
    @Sendable
    @inlinable
    public func modifyInstanceProfile(_ input: ModifyInstanceProfileMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyInstanceProfileResponse {
        try await self.client.execute(
            operation: "ModifyInstanceProfile", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified instance profile using the provided parameters.  All migration projects associated with the instance profile must be deleted or modified before you can modify the instance profile.
    ///
    /// Parameters:
    ///   - availabilityZone: The Availability Zone where the instance profile runs.
    ///   - description: A user-friendly description for the instance profile.
    ///   - instanceProfileIdentifier: The identifier of the instance profile. Identifiers must begin with a letter and must contain  only ASCII letters, digits, and hyphens. They can't end with a hyphen, or contain two consecutive  hyphens.
    ///   - instanceProfileName: A user-friendly name for the instance profile.
    ///   - kmsKeyArn: The Amazon Resource Name (ARN) of the KMS key that is used to encrypt  the connection parameters for the instance profile. If you don't specify a value for the KmsKeyArn parameter, then DMS uses an Amazon Web Services owned encryption key to encrypt your resources.
    ///   - networkType: Specifies the network type for the instance profile. A value of IPV4  represents an instance profile with IPv4 network type and only supports IPv4 addressing.  A value of IPV6 represents an instance profile with IPv6 network type  and only supports IPv6 addressing. A value of DUAL represents an instance  profile with dual network type that supports IPv4 and IPv6 addressing.
    ///   - publiclyAccessible: Specifies the accessibility options for the instance profile. A value of true represents an instance profile with a public IP address. A value of false represents an instance profile with a private IP address. The default value is true.
    ///   - subnetGroupIdentifier: A subnet group to associate with the instance profile.
    ///   - vpcSecurityGroups: Specifies the VPC security groups to be used with the instance profile.  The VPC security group must work with the VPC containing the instance profile.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyInstanceProfile(
        availabilityZone: String? = nil,
        description: String? = nil,
        instanceProfileIdentifier: String,
        instanceProfileName: String? = nil,
        kmsKeyArn: String? = nil,
        networkType: String? = nil,
        publiclyAccessible: Bool? = nil,
        subnetGroupIdentifier: String? = nil,
        vpcSecurityGroups: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyInstanceProfileResponse {
        let input = ModifyInstanceProfileMessage(
            availabilityZone: availabilityZone, 
            description: description, 
            instanceProfileIdentifier: instanceProfileIdentifier, 
            instanceProfileName: instanceProfileName, 
            kmsKeyArn: kmsKeyArn, 
            networkType: networkType, 
            publiclyAccessible: publiclyAccessible, 
            subnetGroupIdentifier: subnetGroupIdentifier, 
            vpcSecurityGroups: vpcSecurityGroups
        )
        return try await self.modifyInstanceProfile(input, logger: logger)
    }

    /// Modifies the specified migration project using the provided parameters.  The migration project must be closed before you can modify it.
    @Sendable
    @inlinable
    public func modifyMigrationProject(_ input: ModifyMigrationProjectMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyMigrationProjectResponse {
        try await self.client.execute(
            operation: "ModifyMigrationProject", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified migration project using the provided parameters.  The migration project must be closed before you can modify it.
    ///
    /// Parameters:
    ///   - description: A user-friendly description of the migration project.
    ///   - instanceProfileIdentifier: The name or Amazon Resource Name (ARN) for the instance profile.
    ///   - migrationProjectIdentifier: The identifier of the migration project. Identifiers must begin with a letter  and must contain only ASCII letters, digits, and hyphens. They can't end with  a hyphen, or contain two consecutive hyphens.
    ///   - migrationProjectName: A user-friendly name for the migration project.
    ///   - schemaConversionApplicationAttributes: The schema conversion application attributes, including the Amazon S3 bucket name and Amazon S3 role ARN.
    ///   - sourceDataProviderDescriptors: Information about the source data provider, including the name, ARN, and Amazon Web Services Secrets Manager parameters.
    ///   - targetDataProviderDescriptors: Information about the target data provider, including the name, ARN, and Amazon Web Services Secrets Manager parameters.
    ///   - transformationRules: The settings in JSON format for migration rules. Migration rules make it possible for you to change  the object names according to the rules that you specify. For example, you can change an object name  to lowercase or uppercase, add or remove a prefix or suffix, or rename objects.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyMigrationProject(
        description: String? = nil,
        instanceProfileIdentifier: String? = nil,
        migrationProjectIdentifier: String,
        migrationProjectName: String? = nil,
        schemaConversionApplicationAttributes: SCApplicationAttributes? = nil,
        sourceDataProviderDescriptors: [DataProviderDescriptorDefinition]? = nil,
        targetDataProviderDescriptors: [DataProviderDescriptorDefinition]? = nil,
        transformationRules: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyMigrationProjectResponse {
        let input = ModifyMigrationProjectMessage(
            description: description, 
            instanceProfileIdentifier: instanceProfileIdentifier, 
            migrationProjectIdentifier: migrationProjectIdentifier, 
            migrationProjectName: migrationProjectName, 
            schemaConversionApplicationAttributes: schemaConversionApplicationAttributes, 
            sourceDataProviderDescriptors: sourceDataProviderDescriptors, 
            targetDataProviderDescriptors: targetDataProviderDescriptors, 
            transformationRules: transformationRules
        )
        return try await self.modifyMigrationProject(input, logger: logger)
    }

    /// Modifies an existing DMS Serverless replication configuration that you can use to start a replication. This command includes input validation and logic to check the state of any replication that uses this configuration. You can only modify a replication configuration before any replication that uses it has started. As soon as you have initially started a replication with a given configuiration, you can't modify that configuration, even if you stop it. Other run statuses that allow you to run this command include FAILED and CREATED. A provisioning state that allows you to run this command is FAILED_PROVISION.
    @Sendable
    @inlinable
    public func modifyReplicationConfig(_ input: ModifyReplicationConfigMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyReplicationConfigResponse {
        try await self.client.execute(
            operation: "ModifyReplicationConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies an existing DMS Serverless replication configuration that you can use to start a replication. This command includes input validation and logic to check the state of any replication that uses this configuration. You can only modify a replication configuration before any replication that uses it has started. As soon as you have initially started a replication with a given configuiration, you can't modify that configuration, even if you stop it. Other run statuses that allow you to run this command include FAILED and CREATED. A provisioning state that allows you to run this command is FAILED_PROVISION.
    ///
    /// Parameters:
    ///   - computeConfig: Configuration parameters for provisioning an DMS Serverless replication.
    ///   - replicationConfigArn: The Amazon Resource Name of the replication to modify.
    ///   - replicationConfigIdentifier: The new replication config to apply to the replication.
    ///   - replicationSettings: The settings for the replication.
    ///   - replicationType: The type of replication.
    ///   - sourceEndpointArn: The Amazon Resource Name (ARN) of the source endpoint for this DMS serverless replication configuration.
    ///   - supplementalSettings: Additional settings for the replication.
    ///   - tableMappings: Table mappings specified in the replication.
    ///   - targetEndpointArn: The Amazon Resource Name (ARN) of the target endpoint for this DMS serverless replication configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyReplicationConfig(
        computeConfig: ComputeConfig? = nil,
        replicationConfigArn: String,
        replicationConfigIdentifier: String? = nil,
        replicationSettings: String? = nil,
        replicationType: MigrationTypeValue? = nil,
        sourceEndpointArn: String? = nil,
        supplementalSettings: String? = nil,
        tableMappings: String? = nil,
        targetEndpointArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyReplicationConfigResponse {
        let input = ModifyReplicationConfigMessage(
            computeConfig: computeConfig, 
            replicationConfigArn: replicationConfigArn, 
            replicationConfigIdentifier: replicationConfigIdentifier, 
            replicationSettings: replicationSettings, 
            replicationType: replicationType, 
            sourceEndpointArn: sourceEndpointArn, 
            supplementalSettings: supplementalSettings, 
            tableMappings: tableMappings, 
            targetEndpointArn: targetEndpointArn
        )
        return try await self.modifyReplicationConfig(input, logger: logger)
    }

    /// Modifies the replication instance to apply new settings. You can change one or more parameters by specifying these parameters and the new values in the request. Some settings are applied during the maintenance window.
    @Sendable
    @inlinable
    public func modifyReplicationInstance(_ input: ModifyReplicationInstanceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyReplicationInstanceResponse {
        try await self.client.execute(
            operation: "ModifyReplicationInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the replication instance to apply new settings. You can change one or more parameters by specifying these parameters and the new values in the request. Some settings are applied during the maintenance window.
    ///
    /// Parameters:
    ///   - allocatedStorage: The amount of storage (in gigabytes) to be allocated for the replication instance.
    ///   - allowMajorVersionUpgrade: Indicates that major version upgrades are allowed. Changing this parameter does not result in an outage, and the change is asynchronously applied as soon as possible. This parameter must be set to true when specifying a value for the EngineVersion parameter that is a different major version than the replication instance's current version.
    ///   - applyImmediately: Indicates whether the changes should be applied immediately or during the next maintenance window.
    ///   - autoMinorVersionUpgrade: A value that indicates that minor version upgrades are applied automatically to the replication instance during the maintenance window. Changing this parameter doesn't result in an outage, except in the case described following. The change is asynchronously applied as soon as possible.  An outage does result if these factors apply:    This parameter is set to true during the maintenance window.   A newer minor version is available.    DMS has enabled automatic patching for the given engine version.
    ///   - engineVersion: The engine version number of the replication instance. When modifying a major engine version of an instance, also set AllowMajorVersionUpgrade to true.
    ///   - kerberosAuthenticationSettings: Specifies the settings required for kerberos authentication when modifying a replication instance.
    ///   - multiAZ:  Specifies whether the replication instance is a Multi-AZ deployment. You can't set the AvailabilityZone parameter if the Multi-AZ parameter is set to true.
    ///   - networkType: The type of IP address protocol used by a replication instance, such as IPv4 only or Dual-stack that supports both IPv4 and IPv6 addressing. IPv6 only is not yet supported.
    ///   - preferredMaintenanceWindow: The weekly time range (in UTC) during which system maintenance can occur, which might result in an outage. Changing this parameter does not result in an outage, except in the following situation, and the change is asynchronously applied as soon as possible. If moving this window to the current time, there must be at least 30 minutes between the current time and end of the window to ensure pending changes are applied. Default: Uses existing setting Format: ddd:hh24:mi-ddd:hh24:mi Valid Days: Mon | Tue | Wed | Thu | Fri | Sat | Sun Constraints: Must be at least 30 minutes
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - replicationInstanceClass: The compute and memory capacity of the replication instance as defined for the specified replication instance class. For example to specify the instance class dms.c4.large, set this parameter to "dms.c4.large". For more information on the settings and capacities for the available replication instance classes, see  Selecting the right DMS replication instance for your migration.
    ///   - replicationInstanceIdentifier: The replication instance identifier. This parameter is stored as a lowercase string.
    ///   - vpcSecurityGroupIds:  Specifies the VPC security group to be used with the replication instance. The VPC security group must work with the VPC containing the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyReplicationInstance(
        allocatedStorage: Int? = nil,
        allowMajorVersionUpgrade: Bool? = nil,
        applyImmediately: Bool? = nil,
        autoMinorVersionUpgrade: Bool? = nil,
        engineVersion: String? = nil,
        kerberosAuthenticationSettings: KerberosAuthenticationSettings? = nil,
        multiAZ: Bool? = nil,
        networkType: String? = nil,
        preferredMaintenanceWindow: String? = nil,
        replicationInstanceArn: String,
        replicationInstanceClass: String? = nil,
        replicationInstanceIdentifier: String? = nil,
        vpcSecurityGroupIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyReplicationInstanceResponse {
        let input = ModifyReplicationInstanceMessage(
            allocatedStorage: allocatedStorage, 
            allowMajorVersionUpgrade: allowMajorVersionUpgrade, 
            applyImmediately: applyImmediately, 
            autoMinorVersionUpgrade: autoMinorVersionUpgrade, 
            engineVersion: engineVersion, 
            kerberosAuthenticationSettings: kerberosAuthenticationSettings, 
            multiAZ: multiAZ, 
            networkType: networkType, 
            preferredMaintenanceWindow: preferredMaintenanceWindow, 
            replicationInstanceArn: replicationInstanceArn, 
            replicationInstanceClass: replicationInstanceClass, 
            replicationInstanceIdentifier: replicationInstanceIdentifier, 
            vpcSecurityGroupIds: vpcSecurityGroupIds
        )
        return try await self.modifyReplicationInstance(input, logger: logger)
    }

    /// Modifies the settings for the specified replication subnet group.
    @Sendable
    @inlinable
    public func modifyReplicationSubnetGroup(_ input: ModifyReplicationSubnetGroupMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyReplicationSubnetGroupResponse {
        try await self.client.execute(
            operation: "ModifyReplicationSubnetGroup", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the settings for the specified replication subnet group.
    ///
    /// Parameters:
    ///   - replicationSubnetGroupDescription: A description for the replication instance subnet group.
    ///   - replicationSubnetGroupIdentifier: The name of the replication instance subnet group.
    ///   - subnetIds: A list of subnet IDs.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyReplicationSubnetGroup(
        replicationSubnetGroupDescription: String? = nil,
        replicationSubnetGroupIdentifier: String,
        subnetIds: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyReplicationSubnetGroupResponse {
        let input = ModifyReplicationSubnetGroupMessage(
            replicationSubnetGroupDescription: replicationSubnetGroupDescription, 
            replicationSubnetGroupIdentifier: replicationSubnetGroupIdentifier, 
            subnetIds: subnetIds
        )
        return try await self.modifyReplicationSubnetGroup(input, logger: logger)
    }

    /// Modifies the specified replication task. You can't modify the task endpoints. The task must be stopped before you can modify it.  For more information about DMS tasks, see Working with Migration Tasks in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func modifyReplicationTask(_ input: ModifyReplicationTaskMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ModifyReplicationTaskResponse {
        try await self.client.execute(
            operation: "ModifyReplicationTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Modifies the specified replication task. You can't modify the task endpoints. The task must be stopped before you can modify it.  For more information about DMS tasks, see Working with Migration Tasks in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - cdcStartPosition: Indicates when you want a change data capture (CDC) operation to start. Use either CdcStartPosition or CdcStartTime to specify when you want a CDC operation to start. Specifying both values results in an error. The value can be in date, checkpoint, or LSN/SCN format. Date Example: --cdc-start-position “2018-03-08T12:12:12” Checkpoint Example: --cdc-start-position "checkpoint:V1#27#mysql-bin-changelog.157832:1975:-1:2002:677883278264080:mysql-bin-changelog.157832:1876#0#0#*#0#93" LSN Example: --cdc-start-position “mysql-bin-changelog.000024:373”  When you use this task setting with a source PostgreSQL database, a logical replication slot should already be created and associated with the source endpoint. You can verify this by setting the slotName extra connection attribute to the name of this logical replication slot. For more information, see Extra Connection Attributes When Using PostgreSQL as a Source for DMS.
    ///   - cdcStartTime: Indicates the start time for a change data capture (CDC) operation. Use either CdcStartTime or CdcStartPosition to specify when you want a CDC operation to start. Specifying both values results in an error. Timestamp Example: --cdc-start-time “2018-03-08T12:12:12”
    ///   - cdcStopPosition: Indicates when you want a change data capture (CDC) operation to stop. The value can be either server time or commit time. Server time example: --cdc-stop-position “server_time:2018-02-09T12:12:12” Commit time example: --cdc-stop-position “commit_time:2018-02-09T12:12:12“
    ///   - migrationType: The migration type. Valid values: full-load | cdc | full-load-and-cdc
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the replication task.
    ///   - replicationTaskIdentifier: The replication task identifier. Constraints:   Must contain 1-255 alphanumeric characters or hyphens.   First character must be a letter.   Cannot end with a hyphen or contain two consecutive hyphens.
    ///   - replicationTaskSettings: JSON file that contains settings for the task, such as task metadata settings.
    ///   - tableMappings: When using the CLI or boto3, provide the path of the JSON file that contains the table mappings. Precede the path with file://. For example, --table-mappings file://mappingfile.json. When working with the DMS API, provide the JSON as the parameter value.
    ///   - taskData: Supplemental information that the task requires to migrate the data for certain source and target endpoints. For more information, see Specifying Supplemental Data for Task Settings in the Database Migration Service User Guide.
    ///   - logger: Logger use during operation
    @inlinable
    public func modifyReplicationTask(
        cdcStartPosition: String? = nil,
        cdcStartTime: Date? = nil,
        cdcStopPosition: String? = nil,
        migrationType: MigrationTypeValue? = nil,
        replicationTaskArn: String,
        replicationTaskIdentifier: String? = nil,
        replicationTaskSettings: String? = nil,
        tableMappings: String? = nil,
        taskData: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ModifyReplicationTaskResponse {
        let input = ModifyReplicationTaskMessage(
            cdcStartPosition: cdcStartPosition, 
            cdcStartTime: cdcStartTime, 
            cdcStopPosition: cdcStopPosition, 
            migrationType: migrationType, 
            replicationTaskArn: replicationTaskArn, 
            replicationTaskIdentifier: replicationTaskIdentifier, 
            replicationTaskSettings: replicationTaskSettings, 
            tableMappings: tableMappings, 
            taskData: taskData
        )
        return try await self.modifyReplicationTask(input, logger: logger)
    }

    /// Moves a replication task from its current replication instance to a different target replication instance using the specified parameters. The target replication instance must be created with the same or later DMS version as the current replication instance.
    @Sendable
    @inlinable
    public func moveReplicationTask(_ input: MoveReplicationTaskMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> MoveReplicationTaskResponse {
        try await self.client.execute(
            operation: "MoveReplicationTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Moves a replication task from its current replication instance to a different target replication instance using the specified parameters. The target replication instance must be created with the same or later DMS version as the current replication instance.
    ///
    /// Parameters:
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the task that you want to move.
    ///   - targetReplicationInstanceArn: The ARN of the replication instance where you want to move the task to.
    ///   - logger: Logger use during operation
    @inlinable
    public func moveReplicationTask(
        replicationTaskArn: String,
        targetReplicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> MoveReplicationTaskResponse {
        let input = MoveReplicationTaskMessage(
            replicationTaskArn: replicationTaskArn, 
            targetReplicationInstanceArn: targetReplicationInstanceArn
        )
        return try await self.moveReplicationTask(input, logger: logger)
    }

    /// Reboots a replication instance. Rebooting results in a momentary outage, until the replication instance becomes available again.
    @Sendable
    @inlinable
    public func rebootReplicationInstance(_ input: RebootReplicationInstanceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> RebootReplicationInstanceResponse {
        try await self.client.execute(
            operation: "RebootReplicationInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Reboots a replication instance. Rebooting results in a momentary outage, until the replication instance becomes available again.
    ///
    /// Parameters:
    ///   - forceFailover: If this parameter is true, the reboot is conducted through a Multi-AZ failover. If the instance isn't configured for Multi-AZ, then you can't specify true. ( --force-planned-failover and --force-failover can't both be set to true.)
    ///   - forcePlannedFailover: If this parameter is true, the reboot is conducted through a planned Multi-AZ failover where resources are released and cleaned up prior to conducting the failover. If the instance isn''t configured for Multi-AZ, then you can't specify true. ( --force-planned-failover and --force-failover can't both be set to true.)
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func rebootReplicationInstance(
        forceFailover: Bool? = nil,
        forcePlannedFailover: Bool? = nil,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RebootReplicationInstanceResponse {
        let input = RebootReplicationInstanceMessage(
            forceFailover: forceFailover, 
            forcePlannedFailover: forcePlannedFailover, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.rebootReplicationInstance(input, logger: logger)
    }

    /// Populates the schema for the specified endpoint. This is an asynchronous operation and can take several minutes. You can check the status of this operation by calling the DescribeRefreshSchemasStatus operation.
    @Sendable
    @inlinable
    public func refreshSchemas(_ input: RefreshSchemasMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> RefreshSchemasResponse {
        try await self.client.execute(
            operation: "RefreshSchemas", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Populates the schema for the specified endpoint. This is an asynchronous operation and can take several minutes. You can check the status of this operation by calling the DescribeRefreshSchemasStatus operation.
    ///
    /// Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func refreshSchemas(
        endpointArn: String,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RefreshSchemasResponse {
        let input = RefreshSchemasMessage(
            endpointArn: endpointArn, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.refreshSchemas(input, logger: logger)
    }

    /// Reloads the target database table with the source data for a given DMS Serverless replication configuration. You can only use this operation with a task in the RUNNING state, otherwise the service will throw an InvalidResourceStateFault exception.
    @Sendable
    @inlinable
    public func reloadReplicationTables(_ input: ReloadReplicationTablesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ReloadReplicationTablesResponse {
        try await self.client.execute(
            operation: "ReloadReplicationTables", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Reloads the target database table with the source data for a given DMS Serverless replication configuration. You can only use this operation with a task in the RUNNING state, otherwise the service will throw an InvalidResourceStateFault exception.
    ///
    /// Parameters:
    ///   - reloadOption: Options for reload. Specify data-reload to reload the data and re-validate it if validation is enabled. Specify validate-only to re-validate the table. This option applies only when validation is enabled for the replication.
    ///   - replicationConfigArn: The Amazon Resource Name of the replication config for which to reload tables.
    ///   - tablesToReload: The list of tables to reload.
    ///   - logger: Logger use during operation
    @inlinable
    public func reloadReplicationTables(
        reloadOption: ReloadOptionValue? = nil,
        replicationConfigArn: String,
        tablesToReload: [TableToReload],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ReloadReplicationTablesResponse {
        let input = ReloadReplicationTablesMessage(
            reloadOption: reloadOption, 
            replicationConfigArn: replicationConfigArn, 
            tablesToReload: tablesToReload
        )
        return try await self.reloadReplicationTables(input, logger: logger)
    }

    /// Reloads the target database table with the source data.  You can only use this operation with a task in the RUNNING state, otherwise the service will throw an InvalidResourceStateFault exception.
    @Sendable
    @inlinable
    public func reloadTables(_ input: ReloadTablesMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> ReloadTablesResponse {
        try await self.client.execute(
            operation: "ReloadTables", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Reloads the target database table with the source data.  You can only use this operation with a task in the RUNNING state, otherwise the service will throw an InvalidResourceStateFault exception.
    ///
    /// Parameters:
    ///   - reloadOption: Options for reload. Specify data-reload to reload the data and re-validate it if validation is enabled. Specify validate-only to re-validate the table. This option applies only when validation is enabled for the task.  Valid values: data-reload, validate-only Default value is data-reload.
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the replication task.
    ///   - tablesToReload: The name and schema of the table to be reloaded.
    ///   - logger: Logger use during operation
    @inlinable
    public func reloadTables(
        reloadOption: ReloadOptionValue? = nil,
        replicationTaskArn: String,
        tablesToReload: [TableToReload],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ReloadTablesResponse {
        let input = ReloadTablesMessage(
            reloadOption: reloadOption, 
            replicationTaskArn: replicationTaskArn, 
            tablesToReload: tablesToReload
        )
        return try await self.reloadTables(input, logger: logger)
    }

    /// Removes metadata tags from an DMS resource, including replication instance, endpoint, subnet group, and migration task. For more information, see  Tag data type description.
    @Sendable
    @inlinable
    public func removeTagsFromResource(_ input: RemoveTagsFromResourceMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> RemoveTagsFromResourceResponse {
        try await self.client.execute(
            operation: "RemoveTagsFromResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes metadata tags from an DMS resource, including replication instance, endpoint, subnet group, and migration task. For more information, see  Tag data type description.
    ///
    /// Parameters:
    ///   - resourceArn: An DMS resource from which you want to remove tag(s). The value for this parameter is an Amazon Resource Name (ARN).
    ///   - tagKeys: The tag key (name) of the tag to be removed.
    ///   - logger: Logger use during operation
    @inlinable
    public func removeTagsFromResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RemoveTagsFromResourceResponse {
        let input = RemoveTagsFromResourceMessage(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.removeTagsFromResource(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Runs large-scale assessment (LSA) analysis on every Fleet Advisor collector in your account.
    @Sendable
    @inlinable
    public func runFleetAdvisorLsaAnalysis(logger: Logger = AWSClient.loggingDisabled) async throws -> RunFleetAdvisorLsaAnalysisResponse {
        try await self.client.execute(
            operation: "RunFleetAdvisorLsaAnalysis", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            logger: logger
        )
    }

    /// Starts the specified data migration.
    @Sendable
    @inlinable
    public func startDataMigration(_ input: StartDataMigrationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartDataMigrationResponse {
        try await self.client.execute(
            operation: "StartDataMigration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts the specified data migration.
    ///
    /// Parameters:
    ///   - dataMigrationIdentifier: The identifier (name or ARN) of the data migration to start.
    ///   - startType: Specifies the start type for the data migration. Valid values include start-replication, reload-target, and resume-processing.
    ///   - logger: Logger use during operation
    @inlinable
    public func startDataMigration(
        dataMigrationIdentifier: String,
        startType: StartReplicationMigrationTypeValue,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartDataMigrationResponse {
        let input = StartDataMigrationMessage(
            dataMigrationIdentifier: dataMigrationIdentifier, 
            startType: startType
        )
        return try await self.startDataMigration(input, logger: logger)
    }

    /// Applies the extension pack to your target database. An extension pack is an add-on module that emulates functions present in a source database that are required when converting objects to the target database.
    @Sendable
    @inlinable
    public func startExtensionPackAssociation(_ input: StartExtensionPackAssociationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartExtensionPackAssociationResponse {
        try await self.client.execute(
            operation: "StartExtensionPackAssociation", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies the extension pack to your target database. An extension pack is an add-on module that emulates functions present in a source database that are required when converting objects to the target database.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger use during operation
    @inlinable
    public func startExtensionPackAssociation(
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartExtensionPackAssociationResponse {
        let input = StartExtensionPackAssociationMessage(
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return try await self.startExtensionPackAssociation(input, logger: logger)
    }

    /// Creates a database migration assessment report by assessing the migration complexity for your source database. A database migration assessment report summarizes all of the schema conversion tasks. It also details the action items for database objects that can't be converted to the database engine of your target database instance.
    @Sendable
    @inlinable
    public func startMetadataModelAssessment(_ input: StartMetadataModelAssessmentMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartMetadataModelAssessmentResponse {
        try await self.client.execute(
            operation: "StartMetadataModelAssessment", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a database migration assessment report by assessing the migration complexity for your source database. A database migration assessment report summarizes all of the schema conversion tasks. It also details the action items for database objects that can't be converted to the database engine of your target database instance.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - selectionRules: A value that specifies the database objects to assess.
    ///   - logger: Logger use during operation
    @inlinable
    public func startMetadataModelAssessment(
        migrationProjectIdentifier: String,
        selectionRules: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartMetadataModelAssessmentResponse {
        let input = StartMetadataModelAssessmentMessage(
            migrationProjectIdentifier: migrationProjectIdentifier, 
            selectionRules: selectionRules
        )
        return try await self.startMetadataModelAssessment(input, logger: logger)
    }

    /// Converts your source database objects to a format compatible with the target database.
    @Sendable
    @inlinable
    public func startMetadataModelConversion(_ input: StartMetadataModelConversionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartMetadataModelConversionResponse {
        try await self.client.execute(
            operation: "StartMetadataModelConversion", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Converts your source database objects to a format compatible with the target database.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - selectionRules: A value that specifies the database objects to convert.
    ///   - logger: Logger use during operation
    @inlinable
    public func startMetadataModelConversion(
        migrationProjectIdentifier: String,
        selectionRules: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartMetadataModelConversionResponse {
        let input = StartMetadataModelConversionMessage(
            migrationProjectIdentifier: migrationProjectIdentifier, 
            selectionRules: selectionRules
        )
        return try await self.startMetadataModelConversion(input, logger: logger)
    }

    /// Saves your converted code to a file as a SQL script, and stores this file on your Amazon S3 bucket.
    @Sendable
    @inlinable
    public func startMetadataModelExportAsScript(_ input: StartMetadataModelExportAsScriptMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartMetadataModelExportAsScriptResponse {
        try await self.client.execute(
            operation: "StartMetadataModelExportAsScript", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Saves your converted code to a file as a SQL script, and stores this file on your Amazon S3 bucket.
    ///
    /// Parameters:
    ///   - fileName: The name of the model file to create in the Amazon S3 bucket.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - origin: Whether to export the metadata model from the source or the target.
    ///   - selectionRules: A value that specifies the database objects to export.
    ///   - logger: Logger use during operation
    @inlinable
    public func startMetadataModelExportAsScript(
        fileName: String? = nil,
        migrationProjectIdentifier: String,
        origin: OriginTypeValue,
        selectionRules: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartMetadataModelExportAsScriptResponse {
        let input = StartMetadataModelExportAsScriptMessage(
            fileName: fileName, 
            migrationProjectIdentifier: migrationProjectIdentifier, 
            origin: origin, 
            selectionRules: selectionRules
        )
        return try await self.startMetadataModelExportAsScript(input, logger: logger)
    }

    /// Applies converted database objects to your target database.
    @Sendable
    @inlinable
    public func startMetadataModelExportToTarget(_ input: StartMetadataModelExportToTargetMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartMetadataModelExportToTargetResponse {
        try await self.client.execute(
            operation: "StartMetadataModelExportToTarget", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Applies converted database objects to your target database.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - overwriteExtensionPack: Whether to overwrite the migration project extension pack. An extension pack is an add-on module  that emulates functions present in a source database that are required when converting objects  to the target database.
    ///   - selectionRules: A value that specifies the database objects to export.
    ///   - logger: Logger use during operation
    @inlinable
    public func startMetadataModelExportToTarget(
        migrationProjectIdentifier: String,
        overwriteExtensionPack: Bool? = nil,
        selectionRules: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartMetadataModelExportToTargetResponse {
        let input = StartMetadataModelExportToTargetMessage(
            migrationProjectIdentifier: migrationProjectIdentifier, 
            overwriteExtensionPack: overwriteExtensionPack, 
            selectionRules: selectionRules
        )
        return try await self.startMetadataModelExportToTarget(input, logger: logger)
    }

    /// Loads the metadata for all the dependent database objects of the parent object. This operation uses your project's Amazon S3 bucket as a metadata cache to improve performance.
    @Sendable
    @inlinable
    public func startMetadataModelImport(_ input: StartMetadataModelImportMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartMetadataModelImportResponse {
        try await self.client.execute(
            operation: "StartMetadataModelImport", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Loads the metadata for all the dependent database objects of the parent object. This operation uses your project's Amazon S3 bucket as a metadata cache to improve performance.
    ///
    /// Parameters:
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - origin: Whether to load metadata to the source or target database.
    ///   - refresh: If true, DMS loads metadata for the specified objects from the source database.
    ///   - selectionRules: A value that specifies the database objects to import.
    ///   - logger: Logger use during operation
    @inlinable
    public func startMetadataModelImport(
        migrationProjectIdentifier: String,
        origin: OriginTypeValue,
        refresh: Bool? = nil,
        selectionRules: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartMetadataModelImportResponse {
        let input = StartMetadataModelImportMessage(
            migrationProjectIdentifier: migrationProjectIdentifier, 
            origin: origin, 
            refresh: refresh, 
            selectionRules: selectionRules
        )
        return try await self.startMetadataModelImport(input, logger: logger)
    }

    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Starts the analysis of your source database to provide recommendations of target engines. You can create recommendations for multiple source databases using BatchStartRecommendations.
    @Sendable
    @inlinable
    public func startRecommendations(_ input: StartRecommendationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws {
        try await self.client.execute(
            operation: "StartRecommendations", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///
    /// End of support notice: On May 20, 2026, Amazon Web Services will end support for Amazon Web Services DMS Fleet Advisor;. After May 20, 2026, you will no longer be able to access the Amazon Web Services DMS Fleet Advisor; console or Amazon Web Services DMS Fleet Advisor; resources. For more information, see Amazon Web Services DMS Fleet Advisor end of support.
    ///   Starts the analysis of your source database to provide recommendations of target engines. You can create recommendations for multiple source databases using BatchStartRecommendations.
    ///
    /// Parameters:
    ///   - databaseId: The identifier of the source database to analyze and provide recommendations for.
    ///   - settings: The settings in JSON format that Fleet Advisor uses to determine target engine recommendations. These parameters include target instance sizing and availability and durability settings. For target instance sizing, Fleet Advisor supports the following two options: total capacity and resource utilization. For availability and durability, Fleet Advisor supports the following two options: production (Multi-AZ deployments) and Dev/Test (Single-AZ deployments).
    ///   - logger: Logger use during operation
    @inlinable
    public func startRecommendations(
        databaseId: String,
        settings: RecommendationSettings,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = StartRecommendationsRequest(
            databaseId: databaseId, 
            settings: settings
        )
        return try await self.startRecommendations(input, logger: logger)
    }

    /// For a given DMS Serverless replication configuration, DMS connects to the source endpoint and collects the metadata to analyze the replication workload. Using this metadata, DMS then computes and provisions the required capacity and starts replicating to the target endpoint using the server resources that DMS has provisioned for the DMS Serverless replication.
    @Sendable
    @inlinable
    public func startReplication(_ input: StartReplicationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReplicationResponse {
        try await self.client.execute(
            operation: "StartReplication", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// For a given DMS Serverless replication configuration, DMS connects to the source endpoint and collects the metadata to analyze the replication workload. Using this metadata, DMS then computes and provisions the required capacity and starts replicating to the target endpoint using the server resources that DMS has provisioned for the DMS Serverless replication.
    ///
    /// Parameters:
    ///   - cdcStartPosition: Indicates when you want a change data capture (CDC) operation to start. Use either CdcStartPosition or CdcStartTime to specify when you want a CDC operation to start. Specifying both values results in an error. The value can be in date, checkpoint, or LSN/SCN format.
    ///   - cdcStartTime: Indicates the start time for a change data capture (CDC) operation. Use either CdcStartTime or CdcStartPosition to specify when you want a CDC operation to start. Specifying both values results in an error.
    ///   - cdcStopPosition: Indicates when you want a change data capture (CDC) operation to stop. The value can be either server time or commit time.
    ///   - premigrationAssessmentSettings: User-defined settings for the premigration assessment. The possible values are:    ResultLocationFolder: The folder within an Amazon S3 bucket where you want DMS to store the results of this assessment run.    ResultEncryptionMode: The supported values are SSE_KMS and SSE_S3. If these values are not provided, then the files are not encrypted at rest. For more information, see Creating Amazon Web Services KMS keys to encrypt Amazon S3 target objects.    ResultKmsKeyArn: The ARN of a customer KMS encryption key that you specify when you set ResultEncryptionMode to SSE_KMS.    IncludeOnly: A space-separated list of names for specific individual assessments that you want to include. These names come from the default list of individual assessments that Database Migration Service supports for the associated migration.    Exclude: A space-separated list of names for specific individual assessments that you want to exclude. These names come from the default list of individual assessments that Database Migration Service supports for the associated migration.    FailOnAssessmentFailure: A configurable setting you can set to true (the default setting) or false. Use this setting to to stop the replication from starting automatically if the assessment fails. This can help you evaluate the issue that is preventing the replication from running successfully.
    ///   - replicationConfigArn: The Amazon Resource Name of the replication for which to start replication.
    ///   - startReplicationType: The replication type. When the replication type is full-load or full-load-and-cdc, the only valid value for the first run of the replication is start-replication. This option will start the replication. You can also use ReloadTables to reload specific tables that failed during replication instead of restarting the replication. The resume-processing option isn't applicable for a full-load replication, because you can't resume partially loaded tables during the full load phase. For a full-load-and-cdc replication, DMS migrates table data, and then applies data changes that occur on the source. To load all the tables again, and start capturing source changes, use reload-target. Otherwise use resume-processing, to replicate the changes from the last stop position.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReplication(
        cdcStartPosition: String? = nil,
        cdcStartTime: Date? = nil,
        cdcStopPosition: String? = nil,
        premigrationAssessmentSettings: String? = nil,
        replicationConfigArn: String,
        startReplicationType: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReplicationResponse {
        let input = StartReplicationMessage(
            cdcStartPosition: cdcStartPosition, 
            cdcStartTime: cdcStartTime, 
            cdcStopPosition: cdcStopPosition, 
            premigrationAssessmentSettings: premigrationAssessmentSettings, 
            replicationConfigArn: replicationConfigArn, 
            startReplicationType: startReplicationType
        )
        return try await self.startReplication(input, logger: logger)
    }

    /// Starts the replication task. For more information about DMS tasks, see Working with Migration Tasks  in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func startReplicationTask(_ input: StartReplicationTaskMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReplicationTaskResponse {
        try await self.client.execute(
            operation: "StartReplicationTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts the replication task. For more information about DMS tasks, see Working with Migration Tasks  in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - cdcStartPosition: Indicates when you want a change data capture (CDC) operation to start. Use either CdcStartPosition or CdcStartTime to specify when you want a CDC operation to start. Specifying both values results in an error. The value can be in date, checkpoint, or LSN/SCN format. Date Example: --cdc-start-position “2018-03-08T12:12:12” Checkpoint Example: --cdc-start-position "checkpoint:V1#27#mysql-bin-changelog.157832:1975:-1:2002:677883278264080:mysql-bin-changelog.157832:1876#0#0#*#0#93" LSN Example: --cdc-start-position “mysql-bin-changelog.000024:373”  When you use this task setting with a source PostgreSQL database, a logical replication slot should already be created and associated with the source endpoint. You can verify this by setting the slotName extra connection attribute to the name of this logical replication slot. For more information, see Extra Connection Attributes When Using PostgreSQL as a Source for DMS.
    ///   - cdcStartTime: Indicates the start time for a change data capture (CDC) operation. Use either CdcStartTime or CdcStartPosition to specify when you want a CDC operation to start. Specifying both values results in an error. Timestamp Example: --cdc-start-time “2018-03-08T12:12:12”
    ///   - cdcStopPosition: Indicates when you want a change data capture (CDC) operation to stop. The value can be either server time or commit time. Server time example: --cdc-stop-position “server_time:2018-02-09T12:12:12” Commit time example: --cdc-stop-position “commit_time:2018-02-09T12:12:12“
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the replication task to be started.
    ///   - startReplicationTaskType: The type of replication task to start.  start-replication is the only valid action that can be used for the first time a task with the migration type of full-loadfull-load, full-load-and-cdc or cdc is run. Any other action used for the first time on a given task, such as resume-processing and reload-target will result in data errors. You can also use ReloadTables to reload specific tables that failed during migration instead of restarting the task. For a full-load task, the resume-processing option will reload any tables that were partially loaded or not yet loaded during the full load phase. For a full-load-and-cdc task, DMS migrates table data, and then applies data changes that occur on the source. To load all the tables again, and start capturing source changes, use reload-target. Otherwise use resume-processing, to replicate the changes from the last stop position. For a cdc only task, to start from a specific position, you must use start-replication and also specify the start position. Check the source endpoint DMS documentation for any limitations. For example, not all sources support starting from a time.   resume-processing is only available for previously executed tasks.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReplicationTask(
        cdcStartPosition: String? = nil,
        cdcStartTime: Date? = nil,
        cdcStopPosition: String? = nil,
        replicationTaskArn: String,
        startReplicationTaskType: StartReplicationTaskTypeValue,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReplicationTaskResponse {
        let input = StartReplicationTaskMessage(
            cdcStartPosition: cdcStartPosition, 
            cdcStartTime: cdcStartTime, 
            cdcStopPosition: cdcStopPosition, 
            replicationTaskArn: replicationTaskArn, 
            startReplicationTaskType: startReplicationTaskType
        )
        return try await self.startReplicationTask(input, logger: logger)
    }

    ///  Starts the replication task assessment for unsupported data types in the source database.  You can only use this operation for a task if the following conditions are true:   The task must be in the stopped state.   The task must have successful connections to the source and target.   If either of these conditions are not met, an InvalidResourceStateFault error will result.  For information about DMS task assessments, see Creating a task assessment report in the Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func startReplicationTaskAssessment(_ input: StartReplicationTaskAssessmentMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReplicationTaskAssessmentResponse {
        try await self.client.execute(
            operation: "StartReplicationTaskAssessment", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Starts the replication task assessment for unsupported data types in the source database.  You can only use this operation for a task if the following conditions are true:   The task must be in the stopped state.   The task must have successful connections to the source and target.   If either of these conditions are not met, an InvalidResourceStateFault error will result.  For information about DMS task assessments, see Creating a task assessment report in the Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - replicationTaskArn:  The Amazon Resource Name (ARN) of the replication task.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReplicationTaskAssessment(
        replicationTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReplicationTaskAssessmentResponse {
        let input = StartReplicationTaskAssessmentMessage(
            replicationTaskArn: replicationTaskArn
        )
        return try await self.startReplicationTaskAssessment(input, logger: logger)
    }

    /// Starts a new premigration assessment run for one or more individual assessments of a migration task. The assessments that you can specify depend on the source and target database engine and the migration type defined for the given task. To run this operation, your migration task must already be created. After you run this operation, you can review the status of each individual assessment. You can also run the migration task manually after the assessment run and its individual assessments complete.
    @Sendable
    @inlinable
    public func startReplicationTaskAssessmentRun(_ input: StartReplicationTaskAssessmentRunMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StartReplicationTaskAssessmentRunResponse {
        try await self.client.execute(
            operation: "StartReplicationTaskAssessmentRun", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Starts a new premigration assessment run for one or more individual assessments of a migration task. The assessments that you can specify depend on the source and target database engine and the migration type defined for the given task. To run this operation, your migration task must already be created. After you run this operation, you can review the status of each individual assessment. You can also run the migration task manually after the assessment run and its individual assessments complete.
    ///
    /// Parameters:
    ///   - assessmentRunName: Unique name to identify the assessment run.
    ///   - exclude: Space-separated list of names for specific individual assessments that you want to exclude. These names come from the default list of individual assessments that DMS supports for the associated migration task. This task is specified by ReplicationTaskArn.  You can't set a value for Exclude if you also set a value for IncludeOnly in the API operation. To identify the names of the default individual assessments that DMS supports for the associated migration task, run the DescribeApplicableIndividualAssessments operation using its own ReplicationTaskArn request parameter.
    ///   - includeOnly: Space-separated list of names for specific individual assessments that you want to include. These names come from the default list of individual assessments that DMS supports for the associated migration task. This task is specified by ReplicationTaskArn.  You can't set a value for IncludeOnly if you also set a value for Exclude in the API operation.  To identify the names of the default individual assessments that DMS supports for the associated migration task, run the DescribeApplicableIndividualAssessments operation using its own ReplicationTaskArn request parameter.
    ///   - replicationTaskArn: Amazon Resource Name (ARN) of the migration task associated with the premigration assessment run that you want to start.
    ///   - resultEncryptionMode: Encryption mode that you can specify to encrypt the results of this assessment run. If you don't specify this request parameter, DMS stores the assessment run results without encryption. You can specify one of the options following:    "SSE_S3" – The server-side encryption provided as a default by Amazon S3.    "SSE_KMS" – Key Management Service (KMS) encryption. This encryption can use either a custom KMS encryption key that you specify or the default KMS encryption key that DMS provides.
    ///   - resultKmsKeyArn: ARN of a custom KMS encryption key that you specify when you set ResultEncryptionMode to "SSE_KMS".
    ///   - resultLocationBucket: Amazon S3 bucket where you want DMS to store the results of this assessment run.
    ///   - resultLocationFolder: Folder within an Amazon S3 bucket where you want DMS to store the results of this assessment run.
    ///   - serviceAccessRoleArn: ARN of the service role needed to start the assessment run. The role must allow the iam:PassRole action.
    ///   - tags: One or more tags to be assigned to the premigration assessment run that you want to start.
    ///   - logger: Logger use during operation
    @inlinable
    public func startReplicationTaskAssessmentRun(
        assessmentRunName: String,
        exclude: [String]? = nil,
        includeOnly: [String]? = nil,
        replicationTaskArn: String,
        resultEncryptionMode: String? = nil,
        resultKmsKeyArn: String? = nil,
        resultLocationBucket: String,
        resultLocationFolder: String? = nil,
        serviceAccessRoleArn: String,
        tags: [Tag]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StartReplicationTaskAssessmentRunResponse {
        let input = StartReplicationTaskAssessmentRunMessage(
            assessmentRunName: assessmentRunName, 
            exclude: exclude, 
            includeOnly: includeOnly, 
            replicationTaskArn: replicationTaskArn, 
            resultEncryptionMode: resultEncryptionMode, 
            resultKmsKeyArn: resultKmsKeyArn, 
            resultLocationBucket: resultLocationBucket, 
            resultLocationFolder: resultLocationFolder, 
            serviceAccessRoleArn: serviceAccessRoleArn, 
            tags: tags
        )
        return try await self.startReplicationTaskAssessmentRun(input, logger: logger)
    }

    /// Stops the specified data migration.
    @Sendable
    @inlinable
    public func stopDataMigration(_ input: StopDataMigrationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StopDataMigrationResponse {
        try await self.client.execute(
            operation: "StopDataMigration", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops the specified data migration.
    ///
    /// Parameters:
    ///   - dataMigrationIdentifier: The identifier (name or ARN) of the data migration to stop.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopDataMigration(
        dataMigrationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopDataMigrationResponse {
        let input = StopDataMigrationMessage(
            dataMigrationIdentifier: dataMigrationIdentifier
        )
        return try await self.stopDataMigration(input, logger: logger)
    }

    /// For a given DMS Serverless replication configuration, DMS stops any and all ongoing DMS Serverless replications. This command doesn't deprovision the stopped replications.
    @Sendable
    @inlinable
    public func stopReplication(_ input: StopReplicationMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StopReplicationResponse {
        try await self.client.execute(
            operation: "StopReplication", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// For a given DMS Serverless replication configuration, DMS stops any and all ongoing DMS Serverless replications. This command doesn't deprovision the stopped replications.
    ///
    /// Parameters:
    ///   - replicationConfigArn: The Amazon Resource Name of the replication to stop.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopReplication(
        replicationConfigArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopReplicationResponse {
        let input = StopReplicationMessage(
            replicationConfigArn: replicationConfigArn
        )
        return try await self.stopReplication(input, logger: logger)
    }

    /// Stops the replication task.
    @Sendable
    @inlinable
    public func stopReplicationTask(_ input: StopReplicationTaskMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> StopReplicationTaskResponse {
        try await self.client.execute(
            operation: "StopReplicationTask", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Stops the replication task.
    ///
    /// Parameters:
    ///   - replicationTaskArn: The Amazon Resource Name(ARN) of the replication task to be stopped.
    ///   - logger: Logger use during operation
    @inlinable
    public func stopReplicationTask(
        replicationTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> StopReplicationTaskResponse {
        let input = StopReplicationTaskMessage(
            replicationTaskArn: replicationTaskArn
        )
        return try await self.stopReplicationTask(input, logger: logger)
    }

    /// Tests the connection between the replication instance and the endpoint.
    @Sendable
    @inlinable
    public func testConnection(_ input: TestConnectionMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> TestConnectionResponse {
        try await self.client.execute(
            operation: "TestConnection", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tests the connection between the replication instance and the endpoint.
    ///
    /// Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger use during operation
    @inlinable
    public func testConnection(
        endpointArn: String,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TestConnectionResponse {
        let input = TestConnectionMessage(
            endpointArn: endpointArn, 
            replicationInstanceArn: replicationInstanceArn
        )
        return try await self.testConnection(input, logger: logger)
    }

    /// Migrates 10 active and enabled Amazon SNS subscriptions at a time and converts them to corresponding Amazon EventBridge rules. By default, this operation migrates subscriptions only when all your replication instance versions are 3.4.5 or higher. If any replication instances are from versions earlier than 3.4.5, the operation raises an error and tells you to upgrade these instances to version 3.4.5 or higher. To enable migration regardless of version, set the Force option to true. However, if you don't upgrade instances earlier than version 3.4.5, some types of events might not be available when you use Amazon EventBridge. To call this operation, make sure that you have certain permissions added to your user account. For more information, see Migrating event subscriptions to Amazon EventBridge in the Amazon Web Services Database Migration Service User Guide.
    @Sendable
    @inlinable
    public func updateSubscriptionsToEventBridge(_ input: UpdateSubscriptionsToEventBridgeMessage, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSubscriptionsToEventBridgeResponse {
        try await self.client.execute(
            operation: "UpdateSubscriptionsToEventBridge", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Migrates 10 active and enabled Amazon SNS subscriptions at a time and converts them to corresponding Amazon EventBridge rules. By default, this operation migrates subscriptions only when all your replication instance versions are 3.4.5 or higher. If any replication instances are from versions earlier than 3.4.5, the operation raises an error and tells you to upgrade these instances to version 3.4.5 or higher. To enable migration regardless of version, set the Force option to true. However, if you don't upgrade instances earlier than version 3.4.5, some types of events might not be available when you use Amazon EventBridge. To call this operation, make sure that you have certain permissions added to your user account. For more information, see Migrating event subscriptions to Amazon EventBridge in the Amazon Web Services Database Migration Service User Guide.
    ///
    /// Parameters:
    ///   - forceMove: When set to true, this operation migrates DMS subscriptions for Amazon SNS notifications no matter what your replication instance version is. If not set or set to false, this operation runs only when all your replication instances are from DMS version 3.4.5 or higher.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSubscriptionsToEventBridge(
        forceMove: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSubscriptionsToEventBridgeResponse {
        let input = UpdateSubscriptionsToEventBridgeMessage(
            forceMove: forceMove
        )
        return try await self.updateSubscriptionsToEventBridge(input, logger: logger)
    }
}

extension DatabaseMigrationService {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: DatabaseMigrationService, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension DatabaseMigrationService {
    /// Return PaginatorSequence for operation ``describeApplicableIndividualAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeApplicableIndividualAssessmentsPaginator(
        _ input: DescribeApplicableIndividualAssessmentsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeApplicableIndividualAssessmentsMessage, DescribeApplicableIndividualAssessmentsResponse> {
        return .init(
            input: input,
            command: self.describeApplicableIndividualAssessments,
            inputKey: \DescribeApplicableIndividualAssessmentsMessage.marker,
            outputKey: \DescribeApplicableIndividualAssessmentsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeApplicableIndividualAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxRecords: Maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - migrationType: Name of the migration type that each provided individual assessment must support.
    ///   - replicationConfigArn: Amazon Resource Name (ARN) of a serverless replication on which you want to base the default list of individual assessments.
    ///   - replicationInstanceArn: ARN of a replication instance on which you want to base the default list of individual assessments.
    ///   - replicationTaskArn: Amazon Resource Name (ARN) of a migration task on which you want to base the default list of individual assessments.
    ///   - sourceEngineName: Name of a database engine that the specified replication instance supports as a source.
    ///   - targetEngineName: Name of a database engine that the specified replication instance supports as a target.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeApplicableIndividualAssessmentsPaginator(
        maxRecords: Int? = nil,
        migrationType: MigrationTypeValue? = nil,
        replicationConfigArn: String? = nil,
        replicationInstanceArn: String? = nil,
        replicationTaskArn: String? = nil,
        sourceEngineName: String? = nil,
        targetEngineName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeApplicableIndividualAssessmentsMessage, DescribeApplicableIndividualAssessmentsResponse> {
        let input = DescribeApplicableIndividualAssessmentsMessage(
            maxRecords: maxRecords, 
            migrationType: migrationType, 
            replicationConfigArn: replicationConfigArn, 
            replicationInstanceArn: replicationInstanceArn, 
            replicationTaskArn: replicationTaskArn, 
            sourceEngineName: sourceEngineName, 
            targetEngineName: targetEngineName
        )
        return self.describeApplicableIndividualAssessmentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeCertificates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeCertificatesPaginator(
        _ input: DescribeCertificatesMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeCertificatesMessage, DescribeCertificatesResponse> {
        return .init(
            input: input,
            command: self.describeCertificates,
            inputKey: \DescribeCertificatesMessage.marker,
            outputKey: \DescribeCertificatesResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeCertificates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the certificates described in the form of key-value pairs. Valid values are certificate-arn and certificate-id.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 10
    ///   - logger: Logger used for logging
    @inlinable
    public func describeCertificatesPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeCertificatesMessage, DescribeCertificatesResponse> {
        let input = DescribeCertificatesMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeCertificatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeConnectionsPaginator(
        _ input: DescribeConnectionsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeConnectionsMessage, DescribeConnectionsResponse> {
        return .init(
            input: input,
            command: self.describeConnections,
            inputKey: \DescribeConnectionsMessage.marker,
            outputKey: \DescribeConnectionsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters applied to the connection. Valid filter names: endpoint-arn | replication-instance-arn
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeConnectionsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeConnectionsMessage, DescribeConnectionsResponse> {
        let input = DescribeConnectionsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeConnectionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeDataMigrations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeDataMigrationsPaginator(
        _ input: DescribeDataMigrationsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeDataMigrationsMessage, DescribeDataMigrationsResponse> {
        return .init(
            input: input,
            command: self.describeDataMigrations,
            inputKey: \DescribeDataMigrationsMessage.marker,
            outputKey: \DescribeDataMigrationsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeDataMigrations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the data migrations.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - withoutStatistics: An option to set to avoid returning information about statistics. Use this to reduce overhead when statistics information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeDataMigrationsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        withoutStatistics: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeDataMigrationsMessage, DescribeDataMigrationsResponse> {
        let input = DescribeDataMigrationsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings, 
            withoutStatistics: withoutStatistics
        )
        return self.describeDataMigrationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeDataProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeDataProvidersPaginator(
        _ input: DescribeDataProvidersMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeDataProvidersMessage, DescribeDataProvidersResponse> {
        return .init(
            input: input,
            command: self.describeDataProviders,
            inputKey: \DescribeDataProvidersMessage.marker,
            outputKey: \DescribeDataProvidersResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeDataProviders(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the data providers described in the form of key-value pairs. Valid filter names and values: data-provider-identifier, data provider arn or name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeDataProvidersPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeDataProvidersMessage, DescribeDataProvidersResponse> {
        let input = DescribeDataProvidersMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeDataProvidersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeEndpointSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEndpointSettingsPaginator(
        _ input: DescribeEndpointSettingsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeEndpointSettingsMessage, DescribeEndpointSettingsResponse> {
        return .init(
            input: input,
            command: self.describeEndpointSettings,
            inputKey: \DescribeEndpointSettingsMessage.marker,
            outputKey: \DescribeEndpointSettingsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeEndpointSettings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - engineName: The database engine used for your source or target endpoint.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEndpointSettingsPaginator(
        engineName: String,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeEndpointSettingsMessage, DescribeEndpointSettingsResponse> {
        let input = DescribeEndpointSettingsMessage(
            engineName: engineName, 
            maxRecords: maxRecords
        )
        return self.describeEndpointSettingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeEndpointTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEndpointTypesPaginator(
        _ input: DescribeEndpointTypesMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeEndpointTypesMessage, DescribeEndpointTypesResponse> {
        return .init(
            input: input,
            command: self.describeEndpointTypes,
            inputKey: \DescribeEndpointTypesMessage.marker,
            outputKey: \DescribeEndpointTypesResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeEndpointTypes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the endpoint types. Valid filter names: engine-name | endpoint-type
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEndpointTypesPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeEndpointTypesMessage, DescribeEndpointTypesResponse> {
        let input = DescribeEndpointTypesMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeEndpointTypesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEndpointsPaginator(
        _ input: DescribeEndpointsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeEndpointsMessage, DescribeEndpointsResponse> {
        return .init(
            input: input,
            command: self.describeEndpoints,
            inputKey: \DescribeEndpointsMessage.marker,
            outputKey: \DescribeEndpointsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the endpoints. Valid filter names: endpoint-arn | endpoint-type | endpoint-id | engine-name
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEndpointsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeEndpointsMessage, DescribeEndpointsResponse> {
        let input = DescribeEndpointsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeEndpointsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeEngineVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEngineVersionsPaginator(
        _ input: DescribeEngineVersionsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeEngineVersionsMessage, DescribeEngineVersionsResponse> {
        return .init(
            input: input,
            command: self.describeEngineVersions,
            inputKey: \DescribeEngineVersionsMessage.marker,
            outputKey: \DescribeEngineVersionsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeEngineVersions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEngineVersionsPaginator(
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeEngineVersionsMessage, DescribeEngineVersionsResponse> {
        let input = DescribeEngineVersionsMessage(
            maxRecords: maxRecords
        )
        return self.describeEngineVersionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeEventSubscriptions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEventSubscriptionsPaginator(
        _ input: DescribeEventSubscriptionsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeEventSubscriptionsMessage, DescribeEventSubscriptionsResponse> {
        return .init(
            input: input,
            command: self.describeEventSubscriptions,
            inputKey: \DescribeEventSubscriptionsMessage.marker,
            outputKey: \DescribeEventSubscriptionsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeEventSubscriptions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to event subscriptions. Valid filter names: event-subscription-arn | event-subscription-id
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - subscriptionName: The name of the DMS event subscription to be described.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEventSubscriptionsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        subscriptionName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeEventSubscriptionsMessage, DescribeEventSubscriptionsResponse> {
        let input = DescribeEventSubscriptionsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            subscriptionName: subscriptionName
        )
        return self.describeEventSubscriptionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEventsPaginator(
        _ input: DescribeEventsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeEventsMessage, DescribeEventsResponse> {
        return .init(
            input: input,
            command: self.describeEvents,
            inputKey: \DescribeEventsMessage.marker,
            outputKey: \DescribeEventsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeEvents(_:logger:)``.
    ///
    /// - Parameters:
    ///   - duration: The duration of the events to be listed.
    ///   - endTime: The end time for the events to be listed.
    ///   - eventCategories: A list of event categories for the source type that you've chosen.
    ///   - filters: Filters applied to events. The only valid filter is replication-instance-id.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - sourceIdentifier:  The identifier of an event source.
    ///   - sourceType: The type of DMS resource that generates events. Valid values: replication-instance | replication-task
    ///   - startTime: The start time for the events to be listed.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeEventsPaginator(
        duration: Int? = nil,
        endTime: Date? = nil,
        eventCategories: [String]? = nil,
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        sourceIdentifier: String? = nil,
        sourceType: SourceType? = nil,
        startTime: Date? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeEventsMessage, DescribeEventsResponse> {
        let input = DescribeEventsMessage(
            duration: duration, 
            endTime: endTime, 
            eventCategories: eventCategories, 
            filters: filters, 
            maxRecords: maxRecords, 
            sourceIdentifier: sourceIdentifier, 
            sourceType: sourceType, 
            startTime: startTime
        )
        return self.describeEventsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeExtensionPackAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeExtensionPackAssociationsPaginator(
        _ input: DescribeExtensionPackAssociationsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeExtensionPackAssociationsMessage, DescribeExtensionPackAssociationsResponse> {
        return .init(
            input: input,
            command: self.describeExtensionPackAssociations,
            inputKey: \DescribeExtensionPackAssociationsMessage.marker,
            outputKey: \DescribeExtensionPackAssociationsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeExtensionPackAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the extension pack associations described in the form of key-value pairs.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The name or Amazon Resource Name (ARN) for the migration project.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeExtensionPackAssociationsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeExtensionPackAssociationsMessage, DescribeExtensionPackAssociationsResponse> {
        let input = DescribeExtensionPackAssociationsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return self.describeExtensionPackAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeFleetAdvisorCollectors(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorCollectorsPaginator(
        _ input: DescribeFleetAdvisorCollectorsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorCollectorsRequest, DescribeFleetAdvisorCollectorsResponse> {
        return .init(
            input: input,
            command: self.describeFleetAdvisorCollectors,
            inputKey: \DescribeFleetAdvisorCollectorsRequest.nextToken,
            outputKey: \DescribeFleetAdvisorCollectorsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeFleetAdvisorCollectors(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those collectors that meet the filter criteria:    collector-referenced-id – The ID of the collector agent, for example d4610ac5-e323-4ad9-bc50-eaf7249dfe9d.    collector-name – The name of the collector agent.   An example is: describe-fleet-advisor-collectors --filter Name="collector-referenced-id",Values="d4610ac5-e323-4ad9-bc50-eaf7249dfe9d"
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorCollectorsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorCollectorsRequest, DescribeFleetAdvisorCollectorsResponse> {
        let input = DescribeFleetAdvisorCollectorsRequest(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeFleetAdvisorCollectorsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeFleetAdvisorDatabases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorDatabasesPaginator(
        _ input: DescribeFleetAdvisorDatabasesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorDatabasesRequest, DescribeFleetAdvisorDatabasesResponse> {
        return .init(
            input: input,
            command: self.describeFleetAdvisorDatabases,
            inputKey: \DescribeFleetAdvisorDatabasesRequest.nextToken,
            outputKey: \DescribeFleetAdvisorDatabasesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeFleetAdvisorDatabases(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those databases that meet the filter criteria:     database-id – The ID of the database.    database-name – The name of the database.    database-engine – The name of the database engine.    server-ip-address – The IP address of the database server.    database-ip-address – The IP address of the database.    collector-name – The name of the associated Fleet Advisor collector.   An example is: describe-fleet-advisor-databases --filter Name="database-id",Values="45"
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorDatabasesPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorDatabasesRequest, DescribeFleetAdvisorDatabasesResponse> {
        let input = DescribeFleetAdvisorDatabasesRequest(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeFleetAdvisorDatabasesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeFleetAdvisorLsaAnalysis(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorLsaAnalysisPaginator(
        _ input: DescribeFleetAdvisorLsaAnalysisRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorLsaAnalysisRequest, DescribeFleetAdvisorLsaAnalysisResponse> {
        return .init(
            input: input,
            command: self.describeFleetAdvisorLsaAnalysis,
            inputKey: \DescribeFleetAdvisorLsaAnalysisRequest.nextToken,
            outputKey: \DescribeFleetAdvisorLsaAnalysisResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeFleetAdvisorLsaAnalysis(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorLsaAnalysisPaginator(
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorLsaAnalysisRequest, DescribeFleetAdvisorLsaAnalysisResponse> {
        let input = DescribeFleetAdvisorLsaAnalysisRequest(
            maxRecords: maxRecords
        )
        return self.describeFleetAdvisorLsaAnalysisPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeFleetAdvisorSchemaObjectSummary(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorSchemaObjectSummaryPaginator(
        _ input: DescribeFleetAdvisorSchemaObjectSummaryRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorSchemaObjectSummaryRequest, DescribeFleetAdvisorSchemaObjectSummaryResponse> {
        return .init(
            input: input,
            command: self.describeFleetAdvisorSchemaObjectSummary,
            inputKey: \DescribeFleetAdvisorSchemaObjectSummaryRequest.nextToken,
            outputKey: \DescribeFleetAdvisorSchemaObjectSummaryResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeFleetAdvisorSchemaObjectSummary(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those schema objects that meet the filter criteria:    schema-id – The ID of the schema, for example d4610ac5-e323-4ad9-bc50-eaf7249dfe9d.   Example: describe-fleet-advisor-schema-object-summary --filter Name="schema-id",Values="50"
    ///   - maxRecords: 
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorSchemaObjectSummaryPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorSchemaObjectSummaryRequest, DescribeFleetAdvisorSchemaObjectSummaryResponse> {
        let input = DescribeFleetAdvisorSchemaObjectSummaryRequest(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeFleetAdvisorSchemaObjectSummaryPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeFleetAdvisorSchemas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorSchemasPaginator(
        _ input: DescribeFleetAdvisorSchemasRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorSchemasRequest, DescribeFleetAdvisorSchemasResponse> {
        return .init(
            input: input,
            command: self.describeFleetAdvisorSchemas,
            inputKey: \DescribeFleetAdvisorSchemasRequest.nextToken,
            outputKey: \DescribeFleetAdvisorSchemasResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeFleetAdvisorSchemas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters:  If you specify any of the following filters, the output includes information for only those schemas that meet the filter criteria:    complexity – The schema's complexity, for example Simple.    database-id – The ID of the schema's database.    database-ip-address – The IP address of the schema's database.    database-name – The name of the schema's database.    database-engine – The name of the schema database's engine.    original-schema-name – The name of the schema's database's main schema.    schema-id – The ID of the schema, for example 15.    schema-name – The name of the schema.    server-ip-address – The IP address of the schema database's server.   An example is: describe-fleet-advisor-schemas --filter Name="schema-id",Values="50"
    ///   - maxRecords: Sets the maximum number of records returned in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeFleetAdvisorSchemasPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeFleetAdvisorSchemasRequest, DescribeFleetAdvisorSchemasResponse> {
        let input = DescribeFleetAdvisorSchemasRequest(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeFleetAdvisorSchemasPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeInstanceProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeInstanceProfilesPaginator(
        _ input: DescribeInstanceProfilesMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeInstanceProfilesMessage, DescribeInstanceProfilesResponse> {
        return .init(
            input: input,
            command: self.describeInstanceProfiles,
            inputKey: \DescribeInstanceProfilesMessage.marker,
            outputKey: \DescribeInstanceProfilesResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeInstanceProfiles(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the instance profiles described in the form of key-value pairs. Valid filter names and values: instance-profile-identifier, instance profile arn or name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeInstanceProfilesPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeInstanceProfilesMessage, DescribeInstanceProfilesResponse> {
        let input = DescribeInstanceProfilesMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeInstanceProfilesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeMetadataModelAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelAssessmentsPaginator(
        _ input: DescribeMetadataModelAssessmentsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelAssessmentsMessage, DescribeMetadataModelAssessmentsResponse> {
        return .init(
            input: input,
            command: self.describeMetadataModelAssessments,
            inputKey: \DescribeMetadataModelAssessmentsMessage.marker,
            outputKey: \DescribeMetadataModelAssessmentsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMetadataModelAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the metadata model assessments described in the form of key-value pairs.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The name or Amazon Resource Name (ARN) of the migration project.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelAssessmentsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelAssessmentsMessage, DescribeMetadataModelAssessmentsResponse> {
        let input = DescribeMetadataModelAssessmentsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return self.describeMetadataModelAssessmentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeMetadataModelConversions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelConversionsPaginator(
        _ input: DescribeMetadataModelConversionsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelConversionsMessage, DescribeMetadataModelConversionsResponse> {
        return .init(
            input: input,
            command: self.describeMetadataModelConversions,
            inputKey: \DescribeMetadataModelConversionsMessage.marker,
            outputKey: \DescribeMetadataModelConversionsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMetadataModelConversions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the metadata model conversions described in the form of key-value pairs.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelConversionsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelConversionsMessage, DescribeMetadataModelConversionsResponse> {
        let input = DescribeMetadataModelConversionsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return self.describeMetadataModelConversionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeMetadataModelExportsAsScript(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelExportsAsScriptPaginator(
        _ input: DescribeMetadataModelExportsAsScriptMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelExportsAsScriptMessage, DescribeMetadataModelExportsAsScriptResponse> {
        return .init(
            input: input,
            command: self.describeMetadataModelExportsAsScript,
            inputKey: \DescribeMetadataModelExportsAsScriptMessage.marker,
            outputKey: \DescribeMetadataModelExportsAsScriptResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMetadataModelExportsAsScript(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the metadata model exports described in the form of key-value pairs.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelExportsAsScriptPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelExportsAsScriptMessage, DescribeMetadataModelExportsAsScriptResponse> {
        let input = DescribeMetadataModelExportsAsScriptMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return self.describeMetadataModelExportsAsScriptPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeMetadataModelExportsToTarget(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelExportsToTargetPaginator(
        _ input: DescribeMetadataModelExportsToTargetMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelExportsToTargetMessage, DescribeMetadataModelExportsToTargetResponse> {
        return .init(
            input: input,
            command: self.describeMetadataModelExportsToTarget,
            inputKey: \DescribeMetadataModelExportsToTargetMessage.marker,
            outputKey: \DescribeMetadataModelExportsToTargetResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMetadataModelExportsToTarget(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the metadata model exports described in the form of key-value pairs.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelExportsToTargetPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelExportsToTargetMessage, DescribeMetadataModelExportsToTargetResponse> {
        let input = DescribeMetadataModelExportsToTargetMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return self.describeMetadataModelExportsToTargetPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeMetadataModelImports(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelImportsPaginator(
        _ input: DescribeMetadataModelImportsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelImportsMessage, DescribeMetadataModelImportsResponse> {
        return .init(
            input: input,
            command: self.describeMetadataModelImports,
            inputKey: \DescribeMetadataModelImportsMessage.marker,
            outputKey: \DescribeMetadataModelImportsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMetadataModelImports(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the metadata model imports described in the form of key-value pairs.
    ///   - maxRecords: A paginated list of metadata model imports.
    ///   - migrationProjectIdentifier: The migration project name or Amazon Resource Name (ARN).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMetadataModelImportsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        migrationProjectIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMetadataModelImportsMessage, DescribeMetadataModelImportsResponse> {
        let input = DescribeMetadataModelImportsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            migrationProjectIdentifier: migrationProjectIdentifier
        )
        return self.describeMetadataModelImportsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeMigrationProjects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMigrationProjectsPaginator(
        _ input: DescribeMigrationProjectsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeMigrationProjectsMessage, DescribeMigrationProjectsResponse> {
        return .init(
            input: input,
            command: self.describeMigrationProjects,
            inputKey: \DescribeMigrationProjectsMessage.marker,
            outputKey: \DescribeMigrationProjectsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeMigrationProjects(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the migration projects described in the form of key-value pairs. Valid filter names and values:   instance-profile-identifier, instance profile arn or name   data-provider-identifier, data provider arn or name   migration-project-identifier, migration project arn or name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than  the specified MaxRecords value, DMS includes a pagination token   in the response so that you can retrieve the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeMigrationProjectsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeMigrationProjectsMessage, DescribeMigrationProjectsResponse> {
        let input = DescribeMigrationProjectsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeMigrationProjectsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeOrderableReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeOrderableReplicationInstancesPaginator(
        _ input: DescribeOrderableReplicationInstancesMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeOrderableReplicationInstancesMessage, DescribeOrderableReplicationInstancesResponse> {
        return .init(
            input: input,
            command: self.describeOrderableReplicationInstances,
            inputKey: \DescribeOrderableReplicationInstancesMessage.marker,
            outputKey: \DescribeOrderableReplicationInstancesResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeOrderableReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeOrderableReplicationInstancesPaginator(
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeOrderableReplicationInstancesMessage, DescribeOrderableReplicationInstancesResponse> {
        let input = DescribeOrderableReplicationInstancesMessage(
            maxRecords: maxRecords
        )
        return self.describeOrderableReplicationInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describePendingMaintenanceActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describePendingMaintenanceActionsPaginator(
        _ input: DescribePendingMaintenanceActionsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribePendingMaintenanceActionsMessage, DescribePendingMaintenanceActionsResponse> {
        return .init(
            input: input,
            command: self.describePendingMaintenanceActions,
            inputKey: \DescribePendingMaintenanceActionsMessage.marker,
            outputKey: \DescribePendingMaintenanceActionsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describePendingMaintenanceActions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: 
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger used for logging
    @inlinable
    public func describePendingMaintenanceActionsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        replicationInstanceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribePendingMaintenanceActionsMessage, DescribePendingMaintenanceActionsResponse> {
        let input = DescribePendingMaintenanceActionsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            replicationInstanceArn: replicationInstanceArn
        )
        return self.describePendingMaintenanceActionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeRecommendationLimitations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeRecommendationLimitationsPaginator(
        _ input: DescribeRecommendationLimitationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeRecommendationLimitationsRequest, DescribeRecommendationLimitationsResponse> {
        return .init(
            input: input,
            command: self.describeRecommendationLimitations,
            inputKey: \DescribeRecommendationLimitationsRequest.nextToken,
            outputKey: \DescribeRecommendationLimitationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeRecommendationLimitations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the limitations described in the form of key-value pairs. Valid filter names: database-id | engine-name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, Fleet Advisor includes a pagination token in the response so that you can retrieve the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeRecommendationLimitationsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeRecommendationLimitationsRequest, DescribeRecommendationLimitationsResponse> {
        let input = DescribeRecommendationLimitationsRequest(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeRecommendationLimitationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeRecommendations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeRecommendationsPaginator(
        _ input: DescribeRecommendationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeRecommendationsRequest, DescribeRecommendationsResponse> {
        return .init(
            input: input,
            command: self.describeRecommendations,
            inputKey: \DescribeRecommendationsRequest.nextToken,
            outputKey: \DescribeRecommendationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeRecommendations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the target engine recommendations described in the form of key-value pairs. Valid filter names: database-id | engine-name
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, Fleet Advisor includes a pagination token in the response so that you can retrieve the remaining results.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeRecommendationsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeRecommendationsRequest, DescribeRecommendationsResponse> {
        let input = DescribeRecommendationsRequest(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeRecommendationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationConfigsPaginator(
        _ input: DescribeReplicationConfigsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationConfigsMessage, DescribeReplicationConfigsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationConfigs,
            inputKey: \DescribeReplicationConfigsMessage.marker,
            outputKey: \DescribeReplicationConfigsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the replication configs.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationConfigsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationConfigsMessage, DescribeReplicationConfigsResponse> {
        let input = DescribeReplicationConfigsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeReplicationConfigsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationInstanceTaskLogs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationInstanceTaskLogsPaginator(
        _ input: DescribeReplicationInstanceTaskLogsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationInstanceTaskLogsMessage, DescribeReplicationInstanceTaskLogsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationInstanceTaskLogs,
            inputKey: \DescribeReplicationInstanceTaskLogsMessage.marker,
            outputKey: \DescribeReplicationInstanceTaskLogsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationInstanceTaskLogs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - replicationInstanceArn: The Amazon Resource Name (ARN) of the replication instance.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationInstanceTaskLogsPaginator(
        maxRecords: Int? = nil,
        replicationInstanceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationInstanceTaskLogsMessage, DescribeReplicationInstanceTaskLogsResponse> {
        let input = DescribeReplicationInstanceTaskLogsMessage(
            maxRecords: maxRecords, 
            replicationInstanceArn: replicationInstanceArn
        )
        return self.describeReplicationInstanceTaskLogsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationInstancesPaginator(
        _ input: DescribeReplicationInstancesMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationInstancesMessage, DescribeReplicationInstancesResponse> {
        return .init(
            input: input,
            command: self.describeReplicationInstances,
            inputKey: \DescribeReplicationInstancesMessage.marker,
            outputKey: \DescribeReplicationInstancesResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication instances. Valid filter names: replication-instance-arn | replication-instance-id | replication-instance-class | engine-version
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationInstancesPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationInstancesMessage, DescribeReplicationInstancesResponse> {
        let input = DescribeReplicationInstancesMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeReplicationInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationSubnetGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationSubnetGroupsPaginator(
        _ input: DescribeReplicationSubnetGroupsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationSubnetGroupsMessage, DescribeReplicationSubnetGroupsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationSubnetGroups,
            inputKey: \DescribeReplicationSubnetGroupsMessage.marker,
            outputKey: \DescribeReplicationSubnetGroupsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationSubnetGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication subnet groups. Valid filter names: replication-subnet-group-id
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationSubnetGroupsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationSubnetGroupsMessage, DescribeReplicationSubnetGroupsResponse> {
        let input = DescribeReplicationSubnetGroupsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeReplicationSubnetGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationTableStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTableStatisticsPaginator(
        _ input: DescribeReplicationTableStatisticsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTableStatisticsMessage, DescribeReplicationTableStatisticsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationTableStatistics,
            inputKey: \DescribeReplicationTableStatisticsMessage.marker,
            outputKey: \DescribeReplicationTableStatisticsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationTableStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the replication table statistics.
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - replicationConfigArn: The replication config to describe.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTableStatisticsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        replicationConfigArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTableStatisticsMessage, DescribeReplicationTableStatisticsResponse> {
        let input = DescribeReplicationTableStatisticsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            replicationConfigArn: replicationConfigArn
        )
        return self.describeReplicationTableStatisticsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationTaskAssessmentResults(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTaskAssessmentResultsPaginator(
        _ input: DescribeReplicationTaskAssessmentResultsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTaskAssessmentResultsMessage, DescribeReplicationTaskAssessmentResultsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationTaskAssessmentResults,
            inputKey: \DescribeReplicationTaskAssessmentResultsMessage.marker,
            outputKey: \DescribeReplicationTaskAssessmentResultsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationTaskAssessmentResults(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) string that uniquely identifies the task. When this input parameter is specified, the API returns only one result and ignore the values of the MaxRecords and Marker parameters.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTaskAssessmentResultsPaginator(
        maxRecords: Int? = nil,
        replicationTaskArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTaskAssessmentResultsMessage, DescribeReplicationTaskAssessmentResultsResponse> {
        let input = DescribeReplicationTaskAssessmentResultsMessage(
            maxRecords: maxRecords, 
            replicationTaskArn: replicationTaskArn
        )
        return self.describeReplicationTaskAssessmentResultsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationTaskAssessmentRuns(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTaskAssessmentRunsPaginator(
        _ input: DescribeReplicationTaskAssessmentRunsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTaskAssessmentRunsMessage, DescribeReplicationTaskAssessmentRunsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationTaskAssessmentRuns,
            inputKey: \DescribeReplicationTaskAssessmentRunsMessage.marker,
            outputKey: \DescribeReplicationTaskAssessmentRunsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationTaskAssessmentRuns(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the premigration assessment runs described in the form of key-value pairs. Valid filter names: replication-task-assessment-run-arn, replication-task-arn, replication-instance-arn, status
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTaskAssessmentRunsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTaskAssessmentRunsMessage, DescribeReplicationTaskAssessmentRunsResponse> {
        let input = DescribeReplicationTaskAssessmentRunsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeReplicationTaskAssessmentRunsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationTaskIndividualAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTaskIndividualAssessmentsPaginator(
        _ input: DescribeReplicationTaskIndividualAssessmentsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTaskIndividualAssessmentsMessage, DescribeReplicationTaskIndividualAssessmentsResponse> {
        return .init(
            input: input,
            command: self.describeReplicationTaskIndividualAssessments,
            inputKey: \DescribeReplicationTaskIndividualAssessmentsMessage.marker,
            outputKey: \DescribeReplicationTaskIndividualAssessmentsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationTaskIndividualAssessments(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the individual assessments described in the form of key-value pairs. Valid filter names: replication-task-assessment-run-arn, replication-task-arn, status
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTaskIndividualAssessmentsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTaskIndividualAssessmentsMessage, DescribeReplicationTaskIndividualAssessmentsResponse> {
        let input = DescribeReplicationTaskIndividualAssessmentsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeReplicationTaskIndividualAssessmentsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTasksPaginator(
        _ input: DescribeReplicationTasksMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTasksMessage, DescribeReplicationTasksResponse> {
        return .init(
            input: input,
            command: self.describeReplicationTasks,
            inputKey: \DescribeReplicationTasksMessage.marker,
            outputKey: \DescribeReplicationTasksResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication tasks. Valid filter names: replication-task-arn | replication-task-id | migration-type | endpoint-arn | replication-instance-arn
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationTasksPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationTasksMessage, DescribeReplicationTasksResponse> {
        let input = DescribeReplicationTasksMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings
        )
        return self.describeReplicationTasksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeReplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationsPaginator(
        _ input: DescribeReplicationsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeReplicationsMessage, DescribeReplicationsResponse> {
        return .init(
            input: input,
            command: self.describeReplications,
            inputKey: \DescribeReplicationsMessage.marker,
            outputKey: \DescribeReplicationsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeReplications(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the replications. Valid filter names: replication-config-arn | replication-config-id
    ///   - maxRecords: The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeReplicationsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeReplicationsMessage, DescribeReplicationsResponse> {
        let input = DescribeReplicationsMessage(
            filters: filters, 
            maxRecords: maxRecords
        )
        return self.describeReplicationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeSchemas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSchemasPaginator(
        _ input: DescribeSchemasMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeSchemasMessage, DescribeSchemasResponse> {
        return .init(
            input: input,
            command: self.describeSchemas,
            inputKey: \DescribeSchemasMessage.marker,
            outputKey: \DescribeSchemasResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeSchemas(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endpointArn: The Amazon Resource Name (ARN) string that uniquely identifies the endpoint.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeSchemasPaginator(
        endpointArn: String,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeSchemasMessage, DescribeSchemasResponse> {
        let input = DescribeSchemasMessage(
            endpointArn: endpointArn, 
            maxRecords: maxRecords
        )
        return self.describeSchemasPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``describeTableStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeTableStatisticsPaginator(
        _ input: DescribeTableStatisticsMessage,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeTableStatisticsMessage, DescribeTableStatisticsResponse> {
        return .init(
            input: input,
            command: self.describeTableStatistics,
            inputKey: \DescribeTableStatisticsMessage.marker,
            outputKey: \DescribeTableStatisticsResponse.marker,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeTableStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to table statistics. Valid filter names: schema-name | table-name | table-state A combination of filters creates an AND condition where each record matches all specified filters.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 500.
    ///   - replicationTaskArn: The Amazon Resource Name (ARN) of the replication task.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeTableStatisticsPaginator(
        filters: [Filter]? = nil,
        maxRecords: Int? = nil,
        replicationTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeTableStatisticsMessage, DescribeTableStatisticsResponse> {
        let input = DescribeTableStatisticsMessage(
            filters: filters, 
            maxRecords: maxRecords, 
            replicationTaskArn: replicationTaskArn
        )
        return self.describeTableStatisticsPaginator(input, logger: logger)
    }
}

extension DatabaseMigrationService.DescribeApplicableIndividualAssessmentsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeApplicableIndividualAssessmentsMessage {
        return .init(
            marker: token,
            maxRecords: self.maxRecords,
            migrationType: self.migrationType,
            replicationConfigArn: self.replicationConfigArn,
            replicationInstanceArn: self.replicationInstanceArn,
            replicationTaskArn: self.replicationTaskArn,
            sourceEngineName: self.sourceEngineName,
            targetEngineName: self.targetEngineName
        )
    }
}

extension DatabaseMigrationService.DescribeCertificatesMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeCertificatesMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeConnectionsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeConnectionsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeDataMigrationsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeDataMigrationsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            withoutSettings: self.withoutSettings,
            withoutStatistics: self.withoutStatistics
        )
    }
}

extension DatabaseMigrationService.DescribeDataProvidersMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeDataProvidersMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeEndpointSettingsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeEndpointSettingsMessage {
        return .init(
            engineName: self.engineName,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeEndpointTypesMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeEndpointTypesMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeEndpointsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeEndpointsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeEngineVersionsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeEngineVersionsMessage {
        return .init(
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeEventSubscriptionsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeEventSubscriptionsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            subscriptionName: self.subscriptionName
        )
    }
}

extension DatabaseMigrationService.DescribeEventsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeEventsMessage {
        return .init(
            duration: self.duration,
            endTime: self.endTime,
            eventCategories: self.eventCategories,
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            sourceIdentifier: self.sourceIdentifier,
            sourceType: self.sourceType,
            startTime: self.startTime
        )
    }
}

extension DatabaseMigrationService.DescribeExtensionPackAssociationsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeExtensionPackAssociationsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            migrationProjectIdentifier: self.migrationProjectIdentifier
        )
    }
}

extension DatabaseMigrationService.DescribeFleetAdvisorCollectorsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeFleetAdvisorCollectorsRequest {
        return .init(
            filters: self.filters,
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeFleetAdvisorDatabasesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeFleetAdvisorDatabasesRequest {
        return .init(
            filters: self.filters,
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeFleetAdvisorLsaAnalysisRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeFleetAdvisorLsaAnalysisRequest {
        return .init(
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeFleetAdvisorSchemaObjectSummaryRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeFleetAdvisorSchemaObjectSummaryRequest {
        return .init(
            filters: self.filters,
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeFleetAdvisorSchemasRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeFleetAdvisorSchemasRequest {
        return .init(
            filters: self.filters,
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeInstanceProfilesMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeInstanceProfilesMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeMetadataModelAssessmentsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeMetadataModelAssessmentsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            migrationProjectIdentifier: self.migrationProjectIdentifier
        )
    }
}

extension DatabaseMigrationService.DescribeMetadataModelConversionsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeMetadataModelConversionsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            migrationProjectIdentifier: self.migrationProjectIdentifier
        )
    }
}

extension DatabaseMigrationService.DescribeMetadataModelExportsAsScriptMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeMetadataModelExportsAsScriptMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            migrationProjectIdentifier: self.migrationProjectIdentifier
        )
    }
}

extension DatabaseMigrationService.DescribeMetadataModelExportsToTargetMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeMetadataModelExportsToTargetMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            migrationProjectIdentifier: self.migrationProjectIdentifier
        )
    }
}

extension DatabaseMigrationService.DescribeMetadataModelImportsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeMetadataModelImportsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            migrationProjectIdentifier: self.migrationProjectIdentifier
        )
    }
}

extension DatabaseMigrationService.DescribeMigrationProjectsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeMigrationProjectsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeOrderableReplicationInstancesMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeOrderableReplicationInstancesMessage {
        return .init(
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribePendingMaintenanceActionsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribePendingMaintenanceActionsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            replicationInstanceArn: self.replicationInstanceArn
        )
    }
}

extension DatabaseMigrationService.DescribeRecommendationLimitationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeRecommendationLimitationsRequest {
        return .init(
            filters: self.filters,
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeRecommendationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeRecommendationsRequest {
        return .init(
            filters: self.filters,
            maxRecords: self.maxRecords,
            nextToken: token
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationConfigsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationConfigsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationInstanceTaskLogsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationInstanceTaskLogsMessage {
        return .init(
            marker: token,
            maxRecords: self.maxRecords,
            replicationInstanceArn: self.replicationInstanceArn
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationInstancesMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationInstancesMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationSubnetGroupsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationSubnetGroupsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationTableStatisticsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationTableStatisticsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            replicationConfigArn: self.replicationConfigArn
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationTaskAssessmentResultsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationTaskAssessmentResultsMessage {
        return .init(
            marker: token,
            maxRecords: self.maxRecords,
            replicationTaskArn: self.replicationTaskArn
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationTaskAssessmentRunsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationTaskAssessmentRunsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationTaskIndividualAssessmentsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationTaskIndividualAssessmentsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationTasksMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationTasksMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            withoutSettings: self.withoutSettings
        )
    }
}

extension DatabaseMigrationService.DescribeReplicationsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeReplicationsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeSchemasMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeSchemasMessage {
        return .init(
            endpointArn: self.endpointArn,
            marker: token,
            maxRecords: self.maxRecords
        )
    }
}

extension DatabaseMigrationService.DescribeTableStatisticsMessage: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> DatabaseMigrationService.DescribeTableStatisticsMessage {
        return .init(
            filters: self.filters,
            marker: token,
            maxRecords: self.maxRecords,
            replicationTaskArn: self.replicationTaskArn
        )
    }
}

// MARK: Waiters

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension DatabaseMigrationService {
    /// Waiter for operation ``describeEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilEndpointDeleted(
        _ input: DescribeEndpointsMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeEndpointsMessage, _>(
            acceptors: [
                .init(state: .success, matcher: AWSErrorCodeMatcher("ResourceNotFoundFault")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("endpoints[].status", expected: "active")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("endpoints[].status", expected: "creating")),
            ],
            minDelayTime: .seconds(5),
            command: self.describeEndpoints
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to the endpoints. Valid filter names: endpoint-arn | endpoint-type | endpoint-id | engine-name
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilEndpointDeleted(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeEndpointsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        try await self.waitUntilEndpointDeleted(input, logger: logger)
    }

    /// Waiter for operation ``describeReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationInstanceAvailable(
        _ input: DescribeReplicationInstancesMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeReplicationInstancesMessage, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESAllPathMatcher("replicationInstances[].replicationInstanceStatus", expected: "available")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationInstances[].replicationInstanceStatus", expected: "deleting")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationInstances[].replicationInstanceStatus", expected: "incompatible-credentials")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationInstances[].replicationInstanceStatus", expected: "incompatible-network")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationInstances[].replicationInstanceStatus", expected: "inaccessible-encryption-credentials")),
            ],
            minDelayTime: .seconds(60),
            command: self.describeReplicationInstances
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication instances. Valid filter names: replication-instance-arn | replication-instance-id | replication-instance-class | engine-version
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationInstanceAvailable(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeReplicationInstancesMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        try await self.waitUntilReplicationInstanceAvailable(input, logger: logger)
    }

    /// Waiter for operation ``describeReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationInstanceDeleted(
        _ input: DescribeReplicationInstancesMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeReplicationInstancesMessage, _>(
            acceptors: [
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationInstances[].replicationInstanceStatus", expected: "available")),
                .init(state: .success, matcher: AWSErrorCodeMatcher("ResourceNotFoundFault")),
            ],
            minDelayTime: .seconds(15),
            command: self.describeReplicationInstances
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeReplicationInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication instances. Valid filter names: replication-instance-arn | replication-instance-id | replication-instance-class | engine-version
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationInstanceDeleted(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeReplicationInstancesMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        try await self.waitUntilReplicationInstanceDeleted(input, logger: logger)
    }

    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskDeleted(
        _ input: DescribeReplicationTasksMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeReplicationTasksMessage, _>(
            acceptors: [
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "ready")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "creating")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "stopped")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "running")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "failed")),
                .init(state: .success, matcher: AWSErrorCodeMatcher("ResourceNotFoundFault")),
            ],
            minDelayTime: .seconds(15),
            command: self.describeReplicationTasks
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication tasks. Valid filter names: replication-task-arn | replication-task-id | migration-type | endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskDeleted(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeReplicationTasksMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings
        )
        try await self.waitUntilReplicationTaskDeleted(input, logger: logger)
    }

    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskReady(
        _ input: DescribeReplicationTasksMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeReplicationTasksMessage, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESAllPathMatcher("replicationTasks[].status", expected: "ready")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "starting")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "running")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "stopping")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "stopped")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "failed")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "modifying")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "testing")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "deleting")),
            ],
            minDelayTime: .seconds(15),
            command: self.describeReplicationTasks
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication tasks. Valid filter names: replication-task-arn | replication-task-id | migration-type | endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskReady(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeReplicationTasksMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings
        )
        try await self.waitUntilReplicationTaskReady(input, logger: logger)
    }

    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskRunning(
        _ input: DescribeReplicationTasksMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeReplicationTasksMessage, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESAllPathMatcher("replicationTasks[].status", expected: "running")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "ready")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "creating")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "stopping")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "stopped")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "failed")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "modifying")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "testing")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "deleting")),
            ],
            minDelayTime: .seconds(15),
            command: self.describeReplicationTasks
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication tasks. Valid filter names: replication-task-arn | replication-task-id | migration-type | endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskRunning(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeReplicationTasksMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings
        )
        try await self.waitUntilReplicationTaskRunning(input, logger: logger)
    }

    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskStopped(
        _ input: DescribeReplicationTasksMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeReplicationTasksMessage, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESAllPathMatcher("replicationTasks[].status", expected: "stopped")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "ready")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "creating")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "starting")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "failed")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "modifying")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "testing")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("replicationTasks[].status", expected: "deleting")),
            ],
            minDelayTime: .seconds(15),
            command: self.describeReplicationTasks
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeReplicationTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Filters applied to replication tasks. Valid filter names: replication-task-arn | replication-task-id | migration-type | endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - withoutSettings: An option to set to avoid returning information about settings. Use this to reduce overhead when setting information is too large. To use this option, choose true; otherwise, choose false (the default).
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilReplicationTaskStopped(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        withoutSettings: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeReplicationTasksMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords, 
            withoutSettings: withoutSettings
        )
        try await self.waitUntilReplicationTaskStopped(input, logger: logger)
    }

    /// Waiter for operation ``describeConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilTestConnectionSucceeds(
        _ input: DescribeConnectionsMessage,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<DescribeConnectionsMessage, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESAllPathMatcher("connections[].status", expected: "successful")),
                .init(state: .failure, matcher: try! JMESAnyPathMatcher("connections[].status", expected: "failed")),
            ],
            minDelayTime: .seconds(5),
            command: self.describeConnections
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``describeConnections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: The filters applied to the connection. Valid filter names: endpoint-arn | replication-instance-arn
    ///   - marker:  An optional pagination token provided by a previous request. If this parameter is specified, the response includes only records beyond the marker, up to the value specified by MaxRecords.
    ///   - maxRecords:  The maximum number of records to include in the response. If more records exist than the specified MaxRecords value, a pagination token called a marker is included in the response so that the remaining results can be retrieved.  Default: 100 Constraints: Minimum 20, maximum 100.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilTestConnectionSucceeds(
        filters: [Filter]? = nil,
        marker: String? = nil,
        maxRecords: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = DescribeConnectionsMessage(
            filters: filters, 
            marker: marker, 
            maxRecords: maxRecords
        )
        try await self.waitUntilTestConnectionSucceeds(input, logger: logger)
    }
}
